Manual C

Grup elaborare suporL curs.
Nua Dumitriu-Lupan, lnspecLor General M.L.C.1.

kodica Pintea, proesor, Liceul Grigore Moisil, 8ucureLi
Adrian Ni(, proesor, Colegiul Na(ional Lmanuil Gojdu, Oradea
Mioara Ni(, proesor, Colegiul Na(ional Lmanuil Gojdu, Oradea
Cristina Sichim, proesor, Colegiul Na(ional Ferdinand l, 8acau
NicoIae OIroiu, proesor Colegiul Na(ional '8.P. Hadeu', 8uzau
Mihai Ttran, cadru didacLic asociaL, UniversiLaLea PoliLehnica 1imioara
Petru !ucovschi, Developer CommuniLy Lead, MicrosoL Romnia
Tudor-loan SaIomie, 1eam Lead MicrosoL SLudenL ParLners,
UniversiLaLea 1ehnica Cluj Napoca
Autori
M..C.T..
MlCkOSOlT.
lntroducere
n Programarea
.Net lramework
N|n|steru|u| Lduca||e,
0ercetr|| ;| I|neretu|u|

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

CUPRINS
CUPRINS.................................................................................................................................................... 1
1. PROGRAMAREA ORIENTAT OBIECT (POO) ..................................................................... 3
1.1. EVOLUIA TEHNICILOR DE PROGRAMARE.................................................................................. 3
1.2. TIPURI DE DATE OBIECTUALE. NCAPSULARE ............................................................................ 3
1.3. SUPRANCRCARE..................................................................................................................... 4
1.4. MOTENIRE ............................................................................................................................... 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. PROPRIETI ............................................................................................................................. 9
1.12. EVENIMENTE I DELEGRI....................................................................................................... 10
1.13. INTERFEE............................................................................................................................... 11
1.14. FIRE DE EXECUIE ................................................................................................................... 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 APLICAIILOR CONSOL .......................................................................................... 15
3.4. STRUCTURA UNUI PROGRAM C#.............................................................................................. 16
3.5. SINTAXA LIMBAJULUI.............................................................................................................. 16
3.6. TIPURI DE DATE....................................................................................................................... 17
3.7. CONVERSII............................................................................................................................... 21
3.8. CONSTANTE............................................................................................................................. 22
3.9. VARIABILE .............................................................................................................................. 22
3.10. EXPRESII I OPERATORI ........................................................................................................... 22
3.11. COLECII ................................................................................................................................. 23
3.12. INSTRUCUNEA FOREACH ......................................................................................................... 23
3.13. INSTRUCIUNILE TRY-CATCH-FINALLY I THROW ................................................................... 23
4. PROGRAMARE VIZUAL........................................................................................................ 25
4.1. CONCEPTE DE BAZ ALE PROGRAMRII 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 INFORMAIILOR DE LA UTILIZATOR ..................................................................... 37
5. APLICAII ORIENTATE PE DATE......................................................................................... 38
5.1. STRUCTURI DE DATE................................................................................................................ 38
5.2. COLECII 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. Evoluia tehnicilor de programare
Programarea nestructurat (un program simplu, ce utilizeaz numai variabile globale);
complicaiile apar cnd prelucrarea devine mai ampl, iar datele se multiplic i se diversific.
Programarea procedural (program principal deservit de subprograme cu parametri
formali, variabile locale i apeluri cu parametri efectivi); se obin avantaje privind depanarea
i reutilizarea codului i se aplic noi tehnici privind transferul parametrilor i vizibilitatea
variabilelor; complicaiile apar atunci cnd la program sunt asignai doi sau mai muli
programatori care nu pot lucra simultan pe un acelai fiier ce conine codul surs.
Programarea modular (gruparea subprogramelor cu
funcionaliti similare n module, implementate i depanate
separat); se obin avantaje privind independena i
ncapsularea (prin separarea zonei de implementare,
pstrnd 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 gestionnd 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
aplicaie nu este avantajoas.
Programarea orientat obiect (programe cu noi tipuri ce
integreaz att datele, ct i metodele asociate crerii,
prelucrrii i distrugerii acestor date); se obin avantaje prin
abstractizarea programrii (programul nu mai este o succesiune
de prelucrri, ci un ansamblu de obiecte care prind via, au
diverse proprieti, sunt capabile de aciuni specifice i care
interacioneaz n cadrul programului); intervin tehnici noi privind
instanierea, derivarea i polimorfismul tipurilor obiectuale.
1.2. Tipuri de date obiectuale. ncapsulare
Un tip de date abstract (ADT) este o entitate caracterizat printr-o structur de date i
un ansamblu de operaii aplicabile acestor date. Considernd, n rezolvarea unei probleme
de gestiune a accesului utilizatorilor la un anumit site, tipul abstract USER, vom obseva c
sunt multe date ce caracterizeaz un utilizator Internet. Totui se va ine cont doar de datele
semnificative pentru problema dat. Astfel, culoarea ochilor este irelevant n acest caz, n
timp ce data naterii poate fi important. n aceeai idee, operaii specifice ca se
nregistreaz, comand on-line pot fi relevante, n timp ce operaia mannc nu este, n
cazul nostru. Evident, nici nu se pun n discuie date sau operaii nespecifice (numrul de
laturi sau aciunea zboar).
Operaiile care sunt accesibile din afara entitii formeaz interfaa acesteia. Astfel,
operaii interne cum ar fi conversia datei de natere la un numr standard calculat de la
01.01.1900 nu fac parte din interfaa tipului de date abstract, n timp ce operaia plaseaz o
comand on-line face parte, deoarece permite interaciunea cu alte obiecte (SITE, STOC etc.)
O instan a unui tip de date abstract este o concretizare a tipului respectiv, 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 operaiile implementate n cadrul tipului de date abstract metode. Spunem c
datele i metodele sunt membrii unui tip de date obiectual. Folosirea unui astfel de tip
presupune: existena definiiei acestuia, apelul metodelor i accesul 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
met1
obiect4
date4
met4
obiect2
date2
met2
obiect3
date3
met3
4 POO i Programare vizual (suport de curs)
Un exemplu de-acum clasic de tip de date abstract este STIVA. Ea poate avea ca date:
numerele naturale din stiv, capacitatea stivei, vrful etc. Iar operaiile specifice pot fi:
introducerea n stiv (push) i extragerea din stiv (pop). La implementarea tipului STIVA,
vom defini o structura de date care s rein valorile memorate n stiv i cmpuri de date
simple pentru: capacitate, numr de elemente etc. Vom mai defini metode (subprograme)
capabile s creeze o stiv vid, care s introduc o valoare n stiv, s extrag valoarea din
vrful stivei, s testeze dac stiva este vid sau dac stiva este plin etc.
Crearea unei instane noi a unui tip obiectual, presupune operaii specifice de
construire a noului obiect, metoda corespunztoare purtnd numele de constructor. Analog,
la desfiinarea unei instane i eliberarea spaiului de memorie aferent datelor sale, se aplic
o metod specific numit destructor
1
.
O aplicaie ce utilizeaz tipul obiectual STIVA, va putea construi dou sau mai multe
stive (de cri de joc, de exemplu), le va umple cu valori distincte, va muta valori dintr-o stiv
n alta dup o anumit regul desfiinnd orice stiv golit, pn ce rmne o singur stiv.
De observat c toate aceste prelucrri recurg la datele, constructorul, destructorul i la
metodele din interfaa tipului STIVA descris mai sus.
Principalul tip obiectual ntlnit n majoritatea mediilor de dezvoltare (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 complet i corect definite,
astfel nct utilizatorul s nu fie nevoit s in cont de detalii ale acestei implementri. El va
accesa datele, prin intermediul proprietilor i va efectua operaiile, prin intermediul
metodelor puse la dispoziie de tipul obiectual definit. Spunem c tipurile de date obiectuale
respect principiul ncapsulrii. 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 realizeaz actualizarea soldului conform
operaiilor de depunere, extragere i aplicare a dobnzilor. EL va utiliza unul sau mai multe
conturi (instane ale tipului CONT), accesnd proprietile i metodele din interfa,
realizatorul tipului obiectual asumndu-i acele griji n momentul definirii tipului CONT.
Permind extensia tipurilor de date abstracte, clasele pot avea la implementare:
date i metode caracterisitice fiecrui obiect din clas (membri de tip instan),
date i metode specifice clasei (membri de tip clas).
Astfel, clasa STIVA poate beneficia, n plus, i de date ale clasei cum ar fi: numrul de
stive generate, numrul maxim sau numrul minim de componente ale 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 membrilor nestatici, exist cte un
exemplar al membrului respectiv pentru fiecare instan a clasei, membrii statici sunt unici,
fiind accesai n comun de toate instanele clasei. Mai mult, membrii statici pot fi referii fr a
crea vreo instan a clasei respective.
1.3. Suprancrcare
Dei nu este o tehnic specific programrii orientat obiect, ea creeaz un anumit
context pentru metodele ce formeaz o clas i modul n care acestea pot fi (ca orice
subprogram) apelate.
Prin suprancarcare se nelege posibilitatea de a defini n acelai domeniu de
vizibilitate
2
mai multe funcii cu acelai nume, dar cu parametri diferiti ca tip i/sau ca numr.
Astfel ansamblul format din numele funciei i lista sa de parametri reprezint o modalitate
unic de identificare numit semntur sau amprent. Suprancrcarea permite obinerea
unor efecte diferite ale apelului n contexte diferite
3
.

1
Datorit tehnicii de suprancrcare C++, Java i C# permit existena mai multor constructori
2
Noiunile generale legate de vizibilitate se consider cunoscute din programarea procedural.
Aspectele specifice i modificatorii de acces/vizibilitate pot fi studiai din documentaiile de referin C#.
3
Capacitatea unor limbaje (este i cazul limbajului C#) de a folosi ca nume al unui
subprogram un operator, reprezint suprancrcarea operatorilor. Aceasta este o facilitate care
Apelul unei funcii care beneficiaz, prin suprancrcare, de dou sau mai multe
semnturi se realizeaz prin selecia funciei a crei semntur se potrivete cel mai bine cu
lista de parametri efectivi (de la apel).
Astfel, poate fi definit metoda comand on-line cu trei semnturi diferite:
comanda_online(cod_prod) cu un parametru ntreg (desemnnd 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. Motenire
Pentru tipurile de date obiectuale class este posibil o operaie de extindere sau
specializare a comportamentului unei clase existente prin definirea unei clase noi ce
motenete datele i metodele clasei de baz, cu aceast ocazie putnd fi redefinii unii
membri existeni sau adugai unii membri noi. Operaia mai poart numele de derivare.
Clasa din care se motenetea se mai numete clas de baz sau superclas. Clasa
care motenete se numete subclas, clas derivat sau clas descendent.
Ca i n Java, n C# o subclas poate moteni de la o singur superclas, adic avem
de-a face cu motenire simpl; aceeai superclas ns poate fi derivat n mai multe
subclase distincte. O subclas, la randul ei, poate fi superclas pentru o alt clas derivat.
O clas de baz impreun cu toate clasele descendente (direct sau indirect) formeaza o
ierarhie de clase. n C#, toate clasele motenesc de la clasa de baz Object.
n contextul mecanismelor de motenire trebuie amintii modificatorii abstract i sealed
aplicai unei clase, modificatori ce oblig la i respectiv se opun procesului de derivare. Astfel, o
clas abstract trebuie obligatoriu derivat, deoarece direct din ea nu se pot obine obiecte
prin operaia de instaniere, 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 urmnd a fi realizat n clasele derivate din clasa curent
4
.
O metod sigilat nu mai poate fi redefinit n clasele derivate 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 stri, s aib comportamente diferite. Polimorfismul
obiectual
5
se manifest n lucrul cu obiecte din clase aparinnd unei ierarhii de clase, unde,
prin redefinirea unor date sau metode, se obin membri diferii avnd ns acelai nume.
Astfel, n cazul unei referiri obiectuale, se pune problema stabilirii datei sau metodei referite.
Comportamentul polimorfic este un element de flexibilitate care permite stabilirea
contextual, n mod dinamic
6
, 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, aparinnd claselor

reduce diferenele dintre operarea la nivel abstract (cu DTA) i apelul metodei ce realizeaz acest
operaie la nivel de implementare obiectual. Dei ajut la sporirea expresivitii codului, prin
suprancrcarea operatorilor i metodelor se pot crea i confuzii.
4
care trebuie s fie i ea abstract (virtual pur, conform terminologiei din C++)
5
deoarece tot aspecte polimorfice mbrac i unele tehnici din programarea clasic sau tehnica
suprancrcrcrii funciilor i operatorilor.
6
Este posibil doar n cazul limbajelor ce permit legarea ntrziat. La limbajele cu "legare
timpurie", adresa la care se face un apel al unui subprogram se stabilete la compilare. La limbajele
cu legare ntrziat, aceast adresa se stabileste doar in momentul rulrii, putndu-se calcula distinct,
n funcie de contextul n care apare apelul.
7
ntr-o alt concepie, 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.
derivate din PIESA, referirea la metoda muta pare nedefinit. Totui mecanismele POO
permit stabilirea, n momentul apelului, a clasei proxime creia i aparine obiectul T i
apelarea metodei corespunztore (mutare de pion sau tur sau alt pies).
Pentru a permite acest mecanism, metodele care necesit o decizie contextual (n
momentul apelului), se decalr ca metode virtuale (cu modificatorul virtual). n mod
curent, n C# modificatorului virtual al funciei din clasa de baz, i corespunde un
specificator override al funciei din clasa derivat ce redefinete funcia din clasa de baz.
O metod ne-virtual nu este polimorfic i, indiferent de clasa creia i aparine
obiectul, va fi invocat metoda din clasa de baz.
1.6. Programare orientat obiect n C#
C# permite utilizarea OOP respectnd toate principiile enunate anterior.
Toate componentele limbajului sunt ntr-un fel sau altul, asociate noiunii de clas.
Programul nsui este o clas avnd metoda static Main() ca punct de intrare, clas ce nu
se instaniaz. Chiar i tipurile predefinite byte, int sau bool sunt clase sigilate derivate
din clasa ValueType din spaiul System. Pentru a evita unele tehnici de programare
periculoase, limbajul ofer tipuri speciale cum ar fi: interfee i delegri. Versiunii 2.0 a
limbajului i s-a adugat un nou tip: clasele generice
8
,
1.7. Declararea unei clase
Sintaxa
9
: [atrib]
o
[modificatori]
o
class [nume_clas] [:clasa_de_baz]
o
[corp_clas]
o

Atributele reprezint informaii declarative cu privire la entitatea definit.
Modificatorii reprezint o secven de cuvinte cheie dintre: new public protected
internal private (modificatori de acces) abstract sealed (modificatori de motenire)
Clasa de baz este clasa de la care motenete clasa curent i poate exista o singur
astfel de clas de baz. Corpul clasei este un bloc de declarri ale membrilor clasei:
constante (valori asociate clasei), cmpuri (variabile), tipuri de date definite de utilizator,
metode (subprograme), constructori, un destructor, proprieti (caracteristici ce pot fi
consultate sau setate), evenimente (instrumente de semnalizare), indexatori (ce permit
indexarea instanelor din cadrul clasei respective) i operatori.
constructorii i destructorul au ca nume numele clasei proxime din care fac parte
10

metodele au nume care nu coincid cu numele clasei sau al altor membri (cu excepia
metodelor, conform mecanismului de suprancrcare)
metodele sau constructorii care au acelai nume trebuie s difere prin semntur
11

se pot defini date i metode statice (caracteristice clasei) i un constructor static care se
execut la iniializarea clasei propriu-zise; ele formeaz un fel de context al clasei
se pot defini date i metode nestatice (de instan) care se multiplic pentru fiecare
instan n parte n cadrul operaiei de instaniere; ele formeaz contextele tuturor
instanelor clasei respective
Exemplul urmtor definete o ierarhie de clase (conform figurii alturate)
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 obine
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 definiia schematic semnific un neterminal, iar
o
semnific o component opional
10
avnd n vedere c ele pot s fac parte dintr-o clas interioar altei clase
11
din semntur nefcnd parte specificatorii ref i out asociai parametrilor
Copil
Fetita Baiat
1.8. Constructori
Sintaxa:
[atrib]
o
[modificatori]
o
[nume_clas] ([list_param_formali]
o
) [:iniializator]
o
[corp_constr]
o
Modificatori: public protected internel private extern
Iniializator: base([list_param]
o
), this([list_param]
o
) ce permite invocarea unui constructor
anume
12
nainte de executarea instruciunilor ce formeaz corpul constructorului curent. Dac
nu este precizat niciun iniializator, se asociaz implicit iniializatorul base().
Corpul constructorului este format din instruciuni care se execut la crearea unui nou obiect al
clasei respective (sau la crearea clasei, n cazul constructorilor cu modificatorul static).
pot exista mai muli constructori care se pot diferenia prin lista lor de parametri
constructorii nu pot fi motenii
dac o clas nu are definit niciun constructor, se va asigna automat constructorul fr
parametri al clasei de baz (clasa object, dac nu este precizat clasa de baz)
Instanierea presupune declararea unei variabile de tipul clasei respective i iniializarea
acesteia prin apelul constructorului clasei (unul dintre ei, dac sunt definii mai muli)
precedat de operatorul new. Acestea se pot realiza i simultan ntr-o instruciune de felul:
[Nume_clas] [nume_obiect]=new [Nume_clas] ([list_param]
o
)
Utilizarea unui constructor fr parametri i a constructorului implicit n clas derivat
public abstract class Copil
{ protected string nume;
public Copil() {nume = Console.ReadLine();} //la iniializarea obiectului se citete
//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 obinut eroare aici
Suprancrcarea constructorilor i definirea explicit a constructorilor n clase derivate
public class Copil
{ protected string nume; //dat acceesibil numai n interiorul clasei i claselor derivate
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 fr 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 definiia constructorului al treilea din clasa Fetita este greit
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 instruciuni care se execut la distrugerea unui
obiect al clasei respective. Pentru orice clas poate fi definit un singur constructor. Destructorii

12
Din clasa de baz (base) sau din clasa insi (this)
13
Preia i specializeaz constructorul al doilea din clasa de baz
14
Este echivalent cu public Fetita():base(){}
nu pot fi motenii. 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 extern
15

Tipul rezultat poate fi un tip definit sau void. Numele poate fi un simplu identificator sau, n
cazul n care definete n mod explicit un membru al unei interfee, numele este de forma
[nume_interfata].[nume_metoda]
Lista de parametri formali este o succesiune de declarri desprite prin virgule, declararea
unui parametru avnd sintaxa: [atrib]
o
[modificator]
o
[tip] [nume]
Modificatorul unui parametru poate fi ref (parametru de intrare i ieire) sau out (parametru
care este numai de ieire). Parametrii care nu au niciun modificator 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 ;
Semntura fiecrei metode este format din numele metodei, modificatorii acesteia,
numrul i tipul parametrilor
16

Numele metodei trebuie s difere de numele oricrui alt membru care nu este metod.
La apelul metodei, orice parametru trebuie s aib acelai modificator 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 corespunztoare unei clase
public class Copil
{ public const int nr_max = 5; //constant
public static int nr_copii=0; //cmp simplu (variabil)
static Copil[] copii=new Copil[nr_max]; //cmp 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);
referina 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 afieaz o list cu numele celor 3 copii

15
Poate fi folosit cel mult unul dintre modificatorii static, virtual I override ; nu pot aprea
mpreun new i override, abstract nu poate s apar cu niciunul dintre static, virtual, sealed, extern;
private nu poate s apar cu niciunul dintre virtual, override i abstract; seald oblig i la override
16
Din semntur (amprent) nu fac parte tipul returnat, numele parametrilor formali i nici
specificatorii ref i out.
17
Se are n vedere i constructorul fr parametri definit i preluat implicit n subclasele din cadrul
primului exemplu din subcapitolul 1.8: public Copil() {nume = Console.ReadLine();}
Definirea datelor i metodelor nestatice corespunztoare 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 redefinire
18

{Console.WriteLine("{0} se joaca cu {1}.", this.nume, jucaria);}
} //suprancrcarea 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 evidenia mai bine comportamentul polimorfic, propunem secvena
urmtoare n care nu se tie exact ce este obiectul copii[i] (de tip Copil, Fetita sau Baiat?):
for (int i=0; i<nr_copii; i++) copii[i].se_joaca;
1.11. Proprieti
Proprietatea este un membru ce permite accesul controlat la datele-membru ale clasei.
Sintaxa: [atrib]
o
[modificatori]
o
[tip] [nume_proprietate] {[metode_de_acces]
o
}
Observaiile privind modificatorii i numele metodelor sunt valabile i n cazul proprietilor.
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 amndou, n orice ordine.
Este o manier de lucru recomandabil aceea de a proteja datele membru (cmpuri) ale
clasei, definind instrumente de acces la acestea: pentru a obine valoarea cmpului respectiv
(get) sau de a memora o anumit valoare n cmpul respectiv (set). Dac metoda de acces
get este perfect asimilabil cu o metod ce retuneaz o valoare (valoarea datei pe care
vrem s-o obinem sau valoarea ei modificat conform unei prelucrri 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 funcie de context) valoarea respectiv
cmpului. Cum parametrul corespunztor valorii transmise nu apare n structura sintactic a
metodei, este de stiut c el este implicit identificat prin cuvntul value. Dac se supune unor
condiii specifice problemei, se face o atribuire de felul cmp=value.
Definirea n clasa Copil a proprietii Nume, corespunztoare cmpului protejat ce reine,
sub forma unui ir de caractere, numele copilului respctiv. Se va observ c proprietatea
este motenit i de clasele derivate Fetita i Biat
19
.
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
Dect cu ajutorul modificatorului new pentru metoda respectiv n clasa derivat
19
Desigur c proprietatea care controleaz accesul la cmpul identificat prin nume se poate
numi cu totul altfel (proprietatea Nume fiind uor de confundat cu cmpul de date nume).
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 delegri
Evenimentele sunt membri ai unei clase ce permit clasei sau obiectelor clasei s fac
notificri, adic s anune celelalte obiecte asupra unor schimbri petrecute la nivelul strii lor.
Clasa furnizoare a unui eveniment public (pune la dispoziia altor clase) acest lucru printr-o
declarare event care asociaz evenimentului un delegat, adic o referin ctre o funcie
necunoscut creia i se precizeaz doar antetul, funcia urmnd a fi implementat la nivelul
claselor interesate de evenimentul respectiv. Este modul prin care se realizeaz comunicarea
ntre obiecte. Tehnica prin care clasele implementeaz metode (handler-e) ce rspund la
evenimente generate de alte clase poart numele de tratare a evenimentelor.
Sintaxa: [atrib]
o
[modificatori]
o
event [tip_delegat] [nume]
Modificatorii permii sunt aceiai ca i la metode.
Tipul delegat este un tip de date ca oricare altul, derivat din clasa sigilat Delegate, din
spaiul 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 evenimente i poate servi i altor
scopuri n afara tratrii evenimentelor. Prezentm n continuare 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 aranjat (orice dou valori succesive
respect o anumit regul), o implementare generic se poate realiza folosind delegri:
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 ctre o funcie necunoscut
{ for (int i = 0; i < nmax-1; i++)
if (!ok(v[i], v[i + 1])) return false;
return true;
}
}
Dac n clasa-program
21
se adug funciile (exprimnd dou reguli de aranjare posibile)
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), cmpul nume era declarat public,
pentru a permite accesul general la cmpul respectiv de date. Iar metodele i constructorii foloseau
identificatorul nume i nu proprietatea Nume.
21
Independent de definiia clasei Vector
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 de 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 alte obiecte sau clase ale
aplicaiei. Se definete un tip delegat TD (s zicem) cu nite parametri de interes
22
i un
eveniment care are ca asociat un delegat E (de tip TD)
23
. Orice obiect x din clasa Vector are
un membru E (iniial null). O clas C interesat s fie ntiinat cnd se face vreo
interschimbare ntr-un vector pentru a genera o animaie (de exemplu), va implementa o
metod M ce realizeaz animaia i va aduga pe M (prin intermediul unui delegat) la x.E
24
.
Cumulnd mai multe astfel de referine, 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 adugate la E.
Care credei c sunt motivele pentru care apelm la evenimente n acest caz, cnd pare
mult mai simplu s apelm direct metoda M la orice interschimbare?
1.13. Interfee
Interfeele sunt foarte importante n programarea orientat pe obiecte, deoarece permit
utilizarea polimorfismului ntr-un sens mai extins.O interfa este o component a aplicaiei,
asemntoare unei clase, ce declar prin membrii si (metode, proprieti, evenimente i
indexatori) un comportament unitar aplicabil mai multor clase, comportament care nu se
poate defini prin ierarhia de clase a aplicaiei.
De exemplu, dac vom considera arborele din figura urmtoare, n care AVERE este o
clas abstract, iar derivarea claselor a fost conceput urmrind proprietile comune ale
componentelor unei averi, atunci o clas VENIT nu este posibil, deoarece ea ar moteni de
la toate clasele evideniate, iar motenirea multipl nu este admis n C#.

22
De exmplu indicii componentelor interschimbate
23
A se observa c evenimentul n sine este anonim, doar delegatul asociat are nume
24
ntr-o atribuire de felul x.E+=new [tip_delegat](M)
VENITURI
(din produse, din
chirii, din dobnzi,
dividende)
calc()
AVERE
Proprietate Bani
Imobiliara Bun Depunere Investiie Credit_primit
Teren
Imobil
B_inchiriat
Productiv
Neproductiv
De_folosin
I_inchiriat
Mobilier
Altul
Actiune
Cot
Credit_acordat
Pentru metodele din cadrul unei interfee nu se d nici o implementare, ci sunt pur i simplu
specificate, implementarea lor fiind furnizat de unele dintre clasele aplicaiei
25
. Nu exist
instaniere n cazul interfeelor, dar se admit derivri, inclusiv moteniri multiple.
n exemplul nostru, se poate defini o interfa VENIT care s conin antetul unei
metode calc (s zicem) pentru calculul venitului obinut, fiecare dintre clasele care
implementeaz interfaa VENIT fiind obligat s furnizeze o implementare (dup o formul
de calcul specific) pentru metoda calc din interfa. Orice clas care dorete s adere la
interfa trebuie s implementeze toate metodele din interfa. Toate clasele care motenesc
dintr-o clas care implementeaz o interfa motenesc, evident, metodele respective, dar le
pot i redefini (de exemplu, clasa Credit_acordat redefinete metoda calc din clasa Investiie,
deoarece formula de calcul implementat acolo nu i se potrivete i ei
26
).
De exemplu, dac presupunem c toate clasele subliniate implementeaz interfaa
VENIT, atunci pentru o avere cu aciuni la dou firme, un imobil 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();
Gsii dou motive pentru care interfaa VENIT i rezovarea de mai sus ofer o soluie
mai bun dect: t=act1.calc()+act2.calc()+casa.calc()+dep.calc().
1.14. Fire de execuie
Programarea prelucrrilor unei aplicaii pe mai multe fire de execuie (multithreading)
presupune descompunerea ansamblului de prelucrri n secvene, unele dintre ele
planificndu-se a fi prelucrate paralel (cvasi-simultan) de ctre procesor n vederea utilizrii
eficiente a acestuia.
Schema alturat este o posibil
planificare a procesului de calcul al
expresiei a(b+c)-bb, unde a, b i c sunt
nite matrice ptrate ale cror
componente se gsesc n fiiere separate.
n orice punct al prelucrrii de pe un fir de execuie se poate genera un nou fir (thread)
cruia i se asociaz un subprogram cu ajutorul unui delegat. n exemplul urmtor, care
utilizeaz spaiul System.Threading, afiarea succesiv a unor secvene de 1 i de 2
demonstraz comutarea executrii de pe un fir pe altul la intervale relativ constante de timp:
static void scrie2()
{ for (int i = 1; i <=300; i++)Console.Write('2');}
{ ThreadStart delegat = new ThreadStart(scrie2);
Thread fir = new Thread(delegat);
fir.Start();
for (int i = 1; i <= 500; i++) Console.Write('1');
Console.ReadKey();}
Spaiul Threading mai ofer faciliti de schimbare a prioritilor prelucrrilor din fire
paralele, de delimitare a secvenelor critice, de ateptare i semnalizare folosind semafoare
etc. O clas sigilat folosit curent n aplicaii (Timer) permite implementarea unui ceas care
funcioneaz pe un fir paralel cu aplicaia 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 implementeaz interfaa respectiv
26
Dac n sens polimorfic spunem c Investiie este i de tip Bani i de tip Avere, tot aa putem
spune c o clas care implementeaz interfaa VENIT i clasele derivate din ea sunt i de tip VENIT
citire b
citire c
Xbb Yb+c
ZaY
UZ-X
citire 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 aplicaiilor-desktop Windows i aplicaiilor WEB.
Tehnologia .NET pune laolalt mai multe tehnologii (ASP, XML, OOP, SOAP, WDSL,
UDDI) i limbaje de programare (VB, C++, C#, J#) asigurnd totodat att portabilitatea
codului compilat ntre diferite calculatoare cu sistem Windows, ct i reutilizarea codului n
programe, indiferent de limbajul de programare utilizat.
.NET Framework este o component livrat npreun cu sistemul de operare Windows.
De fapt, .NET 2.0 vine cu Windows Server 2003 i Windows XP SP2 i se poate instala pe
versiunile anterioare, pn la Windows 98 inclusiv; .NET 3.0 vine instalat pe Windows Vista i
poate fi instalat pe versiunile Windows XP cu SP2 i Windows Server 2003 cu minimum SP1.
Pentru a dezvolta aplicatii pe platforma .NET este bine sa avem 3 componente eseniale:
un set de limbaje (C#, Visual Basic .NET, J#, Managed C++, Smalltalk, 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, aplicaiilor Web i aplicaiilor
desktop Windows.
Cnd dezvoltm aplicaii .NET, putem utiliza:
Servere specializate - un set de servere Enterprise .NET (din familia SQL Server 2000,
Exchange 2000 etc), care pun la dispoziie funcii de stocare a bazelor de date, email,
aplicaii B2B (Bussiness to Bussiness comer electronic ntre partenerii unei afaceri).
Servicii Web (n special comerciale), utile n aplicaii care necesit identificarea
utilizatorilor (de exemplu, .NET Passport - un mod de autentificare folosind un singur
nume i o parol pentru toate ste-urile vizitate)
Servicii incluse pentru dispozitive non-PC (Pocket PC Phone Edition, Smartphone,
Tablet PC, Smart Display, XBox, set-top boxes, etc.)
2.2. .NET Framework
Componenta .NET Framework st la baza tehnologiei .NET, este ultima interfa ntre
aplicaiile .NET i sistemul de operare i actualmente conine:
Limbajele C#, VB.NET, C++ i J#. Pentru a fi integrate n platforma .NET toate aceste
limbaje respect nite specificaii OOP numite Common Type System (CTS). Ele au
ca elemente de baz: clase, interfee, delegri, tipuri valoare i referin, iar ca
mecanisme: motenire, polimorfism i tratarea excepiilor.
Platforma comun de executare a programelor numit Common Language Runtime
(CLR), utilizat de toate cele 4 limbaje.
Ansamblul de biblioteci necesare n realizarea aplicaiilor desktop sau Web numit
Framework Class Library (FCL).
Arhitectura ,NET Framework

Componenta .NET Framework este
format din compilatoare, biblioteci i
alte executabile utile n rularea
aplicaiilor .NET. Fiierele
corespunztoare se afl, n general,
n directorul WINDOWS\Microsoft.
NET\Framework\V2.0.
(corespunztor versiunii instalate)
F
C
L

Framework Base Classes
(IO, securitate, fire de execuie, colecii etc.)
Common Language Runtime
(execepii, validri de tipuri,compilatoare JIT)
Data and XML classes
(ADO.NET, SQL, XML etc.)
Servicii WEB Formulare
CLR
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 obinut are extensia exe, dar nu este direct executabil, ci respect formatul unic MSIL.
CLR include o main virtual asemntoare cu o main Java, ce execut
instruciunile IL rezultate n urma compilrii. Maina folosete un compilator special JIT (Just
In Time). Compilatorul JIT analizeaz codul IL corespunztor apelului unei metode i
produce codul main adecvat i eficient. El recunoate secvenele de cod pentru care s-a
obinut deja codul main adecvat permind reutilizarea acestuia fr recompilare, ceea ce
face ca, pe parcursul rulrii, aplicaiile .NET s fie din ce n ce mai rapide.
Faptul c programul IL produs de diferitele limbaje este foarte asemntor are ca
rezultat interoperabilitatea ntre aceste limbaje. Astfel, clasele 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 mecanism
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 arhitectur ce permite
rularea aplicaiilor .NET, n afar de Windows, i pe unele tipuri 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 restrns de ingineri de la Microsoft, echip din
care s-a evideniat 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 tipuri de date predefinite.
El permite programarea structurat, modular i orientat obiectual, conform perceptelor
moderne ale programrii profesioniste.
Principiile de baz ale programrii pe obiecte (INCAPSULARE, MOSTENIRE,
POLIMORFISM) sunt elemente fundamentale ale programrii C#. n mare, limbajul
motenete sintaxa i principiile de programare din C++. Sunt o serie de tipuri noi de date
sau funciuni diferite ale datelor din C++, iar n spiritul realizrii unor secvene de cod sigure
(safe), unele funciuni au fost adugate (de exemplu, interfee i delegri), diversificate (tipul
struct), modificate (tipul string) sau chiar eliminate (motenirea multipl i pointerii ctre
funcii). Unele funciuni (cum ar fi accesul direct la memorie folosind pointeri) au fost
pstrate, dar secvenele de cod corespunztoare se consider nesigure.
3.2. Compilarea la linia de comand
Se pot dezvolta aplicaii .NET i fr a dispune de mediul de dezvoltare 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, fiierele 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 fiierul primul.cs, n directorul WINDOWS\Microsoft.NET\Framework\V2.0,
atunci scriind la linia de comand: csc primul.cs se va obine fiierul primul.exe direct
executabil pe o platform .NET.
3.3. Crearea aplicaiilor consol
Pentru a realiza aplicaii n mediul de dezvoltare Visual Studio, trebuie s instalm o
versiune a acestuia, eventual versiunea free Microsoft Visual C# 2005 Express Edition de
la adresa http://msdn.microsoft.com/vstudio/express/downloads/default.aspx. Pentru nceput,
putem realiza aplicaii consol (ca i cele din Borland Pascal sau Borland C).
Dup lansare, alegem
opiunea New Project din
meniul File. n fereastra de
dialog (vezi figura), selectm
pictograma Console
Application, dup care, la
Name, introducem numele
aplicaiei noastre.
Fereastra n care scriem
programul se numete
implicit Programs.cs i se
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 opiunii Build Solution (F6) din meniul
Build. Posibilele erori de compilare sunt listate
n fereastra Error List. Efectund dublu click pe
fiecare eroare n parte, cursorul din program se
poziioneaz pe linia coninnd eroarea.
Rularea programului se poate realiza n
mai multe moduri: rapid fr 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 pn la linia
marcat ca punct de ntrerupere (Toggle
Breakpoint F9 pe linia respectiv i apoi Start
Debugging F5). ncetarea urmririi pas cu pas
(Stop Debugging Shift+F5) permite ieirea din
modul depanare i revenirea la modul normal de
lucru. Toate opiunile de rulare i depanare se
gsesc n meniul Debug al meniului.
Fereastra de cod i ferestrele auxiliare ce ne
ajut n etapa de editare pot fi vizualizate alegnd
opiunea corespunztoare din meniul View.
Ferestrele auxiliare utile n etapa de depanare se
pot vizualiza alegnd opiunea corespunztoare
din meniul Debug/Windows.

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 spaii de nume
(namespaces). Un spaiu de nume cuprinde mai multe clase cu nume diferite avnd
funcionaliti nrudite. Dou clase pot avea acelai nume cu condiia ca ele s fie definite n
spaii de nume diferite. n cadrul aceluiai spaiu de nume poate aprea definiia unui alt
spaiu de nume, caz n care avem de-a face cu spaii de nume imbricate. O clas poate fi
identificat prin numele complet (nume precedat de numele spaiului sau spaiilor de nume
din care face parte clasa respectiv, cu separatorul punct). n exemplul nostru,
HelloWorld.Program este numele cu specificaie complet al clasei Program.
O clas este format din date i metode (funcii). Apelarea unei 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 interiorul altei clase, caz n care este
necesar specificarea clasei i apoi a metodei separate prin punct. Dac n plus, clasa
aparine unui spaiu de nume neinclus n fiierul curent, atunci este necesar precizarea
tuturor componentelor numelui: spaiu.clas.metod sau spaiu.spaiu.clas.metod etc.
n fiierul nostru se afl dou spaii 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 spaiul de nume curent este definit doar clasa Program,
deducem c definiia clasei Console trebuie s se gseasc n spaiul System.
Pentru a facilita cooperarea mai multor programatori la realizarea unei aplicaii
complexe, exist posibilitatea de a segmenta aplicaia n mai multe fiiere numite
assemblies. ntr-un assembly se pot implementa mai multe spaii de nume, iar pari ale unui
aceeai spaiu de nume se pot regsi n mai multe assembly-uri. Pentru o aplicaie consol,
ca i pentru o aplicaie Windows de altfel, este obligatoriu ca una (i numai una) dintre clasele
aplicaiei s conin un punct de intrare (entry point), i anume metoda (funcia) Main.
S comentm programul de mai sus:
linia 1: este o directiv care specific faptul c se vor folosi clase incluse n spaiul de nume
System. n cazul nostru se va folosi clasa Console.
linia 3: spaiul nostru de nume
linia 5: orice program C# este alctuit 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 operaiile de intrare/ieire. Aici
se apeleaz metoda WriteLine din acest clas, pentru afiarea mesajului dorit pe ecran.
3.5. Sintaxa limbajului
Ca i limbajul C++ cu care se nrudete, limbajul C# are un alfabet format din litere
mari i mici ale alfabetului englez, cifre i alte semne. Vocabularul limbajului este format din
acele simboluri
27
cu semnificaii lexicale n scrierea programelor: cuvinte (nume), expresii,
separatori, delimitatori i comentarii.

27
Este un termen folosit un pic echivoc i provenit din traduceriea cuvntului token
Limbajul C# 17
Comentarii
comentariu pe un rnd prin folosirea // Tot ce urmeaz dup caracterele // sunt
considerate, din acel loc, pn la sfritul rndului drept comentariu
// Acesta este un comentariu pe un singur rand
comentariu pe mai multe rnduri prin folosirea /* i */ Orice text cuprins ntre
simbolurile menionate mai sus se consider a fi comentariu. Simbolurile /* reprezint
nceputul comentariului, iar */ sfritul respectivului comentariu.
/* Acesta este un
comentariu care se
intinde pe mai multe randuri */
Nume
Prin nume dat unei variabile, clase, metode etc. nelegem o succesiune de caractere
care ndeplinete urmtoarele reguli:
numele trebuie s nceap cu o liter sau cu unul dintre caracterele _ i @;
primul caracter poate fi urmat numai de litere, cifre sau un caracter de subliniere;
numele care reprezint cuvinte cheie nu pot fi folosite n alt scop dect acela
pentru care au fost definite
cuvintele cheie pot fi folosite n alt scop numai dac sunt precedate de @
dou nume sunt distincte dac difer prin cel puin un caracter (fie el i liter mic
ce difer de aceeai liter majuscul)
Convenii pentru nume:
n cazul numelor claselor, metodelor, a proprietilor, enumerrilor, interfeelor,
spaiilor de nume, fiecare cuvnt care compune numele ncepe cu majuscul
n cazul numelor variabilelor dac numele este compus din mai multe 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 reprezentnd constante, regulile de formare a expresiilor,
separatorii de liste, delimitatorii de instruciuni, de blocuri de instruciuni, de iruri de
caractere etc. sunt n mare aceiai 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
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 rndul ei
din clasa Object (alias pentru System.Object).
Limbajul C# conine 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 rdcina oricrui tip
string secven de caractere Unicode
sbyte tip ntreg cu semn, pe 8 bii -128; 127
short tip ntreg cu semn, pe 16 bii -32768; 32767
int tip ntreg cu semn pe, 32 bii -2147483648; 21447483647
long tip ntreg cu semn, pe 64 de bii -9223372036854775808;
9223372036854775807
byte tip ntreg fr semn, pe 8 bii 0; 255
ushort tip ntreg fr semn, pe 16 bii 0; 65535
uint tip ntreg fr semn, pe 32 bii 0; 4294967295
ulong tip ntreg fr semn, pe 64 bii 0; 18446744073709551615
float tip cu virgul mobil, simpl precizie, pe
32 bii (8 pentru exponent, 24 pentru
mantis)
-3.402823E+38; 3.402823E+38
double tip cu virgul mobil, dubl precizie, pe
64 bii (11 pentru exponent, 53 -mantisa)
-1.79769313486232E+308;
1.79769313486232E+308
bool tip boolean -
79228162514264337593543950335;
79228162514264337593543950335
char tip caracter din setul Unicode, pe 16 bii
decimal tip zecimal, pe 128 bii (96 pentru
mantis), 28 de cifre semnificative

O valoare se asigneaz dup urmtoarele 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 permite utilizarea numelor
care, sunt asociate unor valori numerice. Toate componentele enumerate au un acelai tip
de baz ntreg. n cazul n care, la declarare, nu se specific tipul de baz al enumerrii,
atunci acesta este considerat implicit int.
Declararea unui tip enumerare este de forma:
enum [Nume_tip] [: Tip]
o

{
[identificator1][=valoare]
o
,
...
[identificatorn][=valoare]
o

}
Observaii:
n mod implicit valoarea primului membru al enumerrii este 0, iar fiecare variabil care
urmeaz are valoarea (implicit) mai mare cu o unitate dect precedenta.
Valorile folosite pentru iniializri trebuie s fac parte din domeniul de valori declarat al
tipului
Nu se admit referine 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
}
{
Console.WriteLine("Luna Mai este a ",
(int)lunaAnului.Mai + "a luna din an.");
Console.ReadLine();
}
}
}
n urma rulrii programului se afieaz mesajul :
Luna Mai este a 5 a luna din an.
Tablouri
Declararea unui tablou unidimensional:
Tip[] nume;
Prin aceasta, nu se aloc spaiu pentru memorare. Pentru a putea reine date n
structura de tip tablou, este necesar o operaie de instaniere:
nume = new Tip[NumarElemente];
Declararea, instanierea i chiar iniializarea tabloului se pot face n aceeai instruciune:
Exemplu:
int[] v = new int[] {1,2,3}; sau
int[] v = {1,2,3}; //new este implicit
n cazul tablourilor cu mai multe dimensiuni facem distincie ntre tablouri regulate i
tablouri neregulate (tablouri de tablouri)
Declarare n cazul tablourilor regulate bidimensionale:
Tip[,] nume;
Intaniere:
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;
Intaniere:
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 conine ntre ghilimele zero sau mai multe caractere, inclusiv secvene escape.
Secvenele escape permit reprezentarea caracterelor care nu au reprezentare grafic
precum i reprezentarea unor caractere speciale: backslash, caracterul 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 rnd
\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 secvene escape, putem utiliza irurile verbatim. Aceste iruri
pot s conin orice fel de caractere, inclusiv caracterul EOLN. Ele se folosesc n special n
cazul n care dorim s facem referiri la fiiere i la regitri. Un astfel de ir ncepe
ntotdeauna cu simbolul@ naintea ghilimelelor de nceput.
Exemplu:
using System;
namespace SiruriDeCaractere
{
class Program
{
{
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 ieirea
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 afectat valoarea
convertit. Regulile de conversie implicit sunt descrise de tabelul urmtor:
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 cnd nu
exist posibilitatea unei conversii implicite.
Exemplu:
int i=Console.Read(); char c;
c=char(i);
Conversii boxing i unboxing
Datorit faptului c n C# toate tipurile sunt derivate din clasa Object
(System.Object), prin conversiile boxing (mpachetare) i unboxing (despachetare) este
permis tratarea tipurilor valoare drept obiecte i reciproc. Prin conversia boxing a unui tip
valoare, care se pstreaz pe stiv, se produce ambalarea n interiorul unei instane de tip
referin, care se pstraz n memoria heap, la clasa Object. Unboxing permite convertirea
unui obiect ntr-un tipul valoare corespunztor.
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 modaliti de declarare a constantelor: folosind const sau folosind
modificatorul readonly. Constantele declarate cu const trebuie s fie iniializate 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 conin fie o valoare a unui tip elementar, fie o referin la
un obiect.
Exemple:
int Salut;
int Azi_si _maine;
char caracter;
3.10. Expresii i operatori
Prin expresie se nelege o secven format din operatori i operanzi. Un operator
este un simbol ce indic aciunea care se efectueaz, iar operandul este valoarea asupra
creia se execut operaia.
n C# sunt definii mai muli operatori. n cazul n care ntr-o expresie nu intervin
paranteze, operaiile se execut conform prioritii operatorilor. n cazul n care sunt mai
muli operatori cu aceeai prioritate, evaluarea expresiei se realizeaz de la stnga 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 Relaional < > <= >= is as
6 De egalitate == !=
Limbajul C# 23
7 AND (SI) logic &
8 XOR (SAU
exclusiv) logic
^
9 OR (SAU) logic |
10 AND (SI)
condiional
&&
11 OR (SAU)
condiional
||
12 Condiional ?:
13 De atribuire = *= /= %= += -= ^= &= <<= >>= |=
3.11. Colecii
O colecie n C# este o clas specializat pentru memorarea i regsirea rapid a
informaiilor. Ea implementeaz metode specifice de actualizare dinamic coleciei, de
cutare i de enumerare a datelor. Cel mai des folosite sunt coleciile de obiecte i coleciile
generice (vezi capitolul 5.1) cum ar fi liste, stive, hash-uri. Aceste clase pot fi derivate pentru
a obine colecii specializate care se potrivesc cel mai bine necesitilor de memorare a
datelor specifice unei aplicaii. Coleciile sunt definite n spaiul System.Collection. Metodele
uzuale ale claselor din spaiul Collection sunt: Add, Remove, IndexOf, Sort, Reverse,
CopyToArray, Find, Foreach etc.
3.12. Instrucunea foreach
Cum instruciunile de apel, atribuire, decizie, selecie i trei structuri repetitive coincid
ca form i funcionalitate cu cele din C, ne oprim sumar numai unora dintre noile structuri de
control specifice limbajului C#.
Instruciunea foreach enumer elementele dintr-o colecie sau dintr-un tablou,
executnd un bloc de instruciuni pentru fiecare element al coleciei sau tabloului. La fiecare
iteraie, elementul curent al coleciei este de tip readonly, neputnd fi modificat. Amintim c
n instruciunea repetitiv foreach se pot utiliza cu exact aceeai funcionalitate
instruciunile de salt break i continue.
instruciunea se utilizeaz curent n aplicaii pentru tablouri i colecii de obiecte
28
.
Pentru a vedea cum acioneaz o vom compara cu instruciunea cunoscut for. Fie
vectorul nume format din iruri de caractere:
string[] nume={Ana, Ionel, Maria};
S afiam acest ir folosind instruciunea for:
for(int i=0; i<nume.Length; i++)
{
Console.Write({0} , nume[i]);
}
Acelai rezultat l obinem folosind instruciunea foreach:
foreach (string copil in nume)
{
Console.Write({0} , copil);
}
3.13. Instruciunile try-catch-finally i throw
Prin excepie se nelege un obiect care ncapsuleaz informaii despre situaii
anormale n funcionarea unui program. Ea se folosete pentru a semnala contextul n care

28
de exemplu, pentru prelucrarea sistematic a tuturor componentlelor unei ferestre (butoane,
liste, casete de text etc.)
apare o situaie special. De exemplu: erori la deschiderea unor fiiere, mprire la 0 etc.
Aceste erori se pot manipula astfel nct programul s nu se termine abrupt.
Sunt situaii n care prefigurm apariia unei erori ntr-o secven de prelucrare i atunci
integrm secvena respectiv n blocul unei instruciuni try, preciznd una sau mai multe
secvene de program pentru tratarea excepiilor aprute (blocuri catch) i eventual o
secven comun care se execut dup terminarea normal sau dup recuperarea
programului din starea de excepie (blocul finally).
Exemplu:
using System;
using System.IO;
class tryCatch
{
{ 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 aruncnd o excepie
(instruciunea throw) sau putem profita de mecanismul de tratare a erorilor pentru a
implementa un sistem de validare a datelor prin generarea unei excepii proprii pe care, de
asemenea, o aruncm n momentul nendeplinirii unor condiii puse asupra datelor.
Clasa System.Exception i derivate ale acesteia servesc la tratarea adecvat i
diversificat a excepiilor.
Exemplu: Considerm clasele Copil, Fetita, Baiat definite fragmentat n capitolul 1. O
posibilitate de validare la adugara unui copil este aceea care genereaz o excepie proprie
la depirea 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 programrii vizuale
Programarea vizual trebuie privit ca un mod de proiectare a unui program prin
operare direct asupra unui set de elemente grafice (de aici vine denumirea de programare
vizual). Aceast operare are ca efect scrierea automat a unor secvene de program,
secvene care, mpreun cu secvenele scrise textual
29
, vor forma programul.
Spunem c o aplicaie este vizual dac dispune de o interfa grafic sugestiv i
pune la dispoziia utilizatorului instrumente specifice de utilizare (drag, click, hint etc.)
Realizarea unei aplicaii vizuale nu const doar n desenare i aranjare de controale, ci
presupune n principal stabilirea unor decizii arhitecturale
30
, 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 astfel de aplicaii
este foarte mic, o parte a codului este generat automat de Visual Stdio.Net, codul nu
este foarte uor de ntreinut i este recomandat pentru aplicaii relativ mici sau cu multe
operaii 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 aplicaiei: conine obiectele de business,
ncapsuleaz accesul la date), View (sunt utilizate elemente de interfa, este format
din Form-uri), Controller( proceseaz i rspunde la evenimente iar SO, clasele Form
i Control din .Net ruteaz evenimentul ctre un handler, eveniment tratat n codul din
spatele Form-urilor).
c) Modelul arhitectural Multi-nivel
Nivelul de prezentare ( interfaa)
Se ocup numai de afiarea informaiilor ctre
utilizator i captarea celor introduse de acesta. Nu
cuprinde detalii despre logica aplicaiei, i cu att
mai mult despre baza de date sau fiierele pe
care aceasta le utilizeaz. Cu alte cuvinte, n
cadrul interfeei cu utilizatorul, nu se vor folosi
obiecte de tipuri definite de programator, ci numai
baza din .NET.
Nivelul de logic a aplicaiei
Se ocup de tot ceea ce este specific aplicaiei
care se dezvolt. Aici se efectueaz calculele i
procesrile 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 fiiere, la alte servicii.

Aceast ultim structur este foarte bun pentru a organiza aplicaiile, dar nu este uor
de realizat. De exemplu, dac n interfaa cu utilizatorul prezentm date sub form ListView
i la un moment dat clientul ne cere reprezentarea datelor ntr-un GridView, modificrile 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 dintre vizual (operaii asupra unor componente grafice) i textual
(scriere de linii de cod); proiectarea oricrei aplicaii vizuale mbin ambele tehnici.
30
Deciziile arhitecturale stabilesc n principal cum se leag interfaa de restul aplicaiei i ct de
uor de ntreinut este codul rezultat.
Indiferent de modelul arhitectural ales, n realizarea aplicaiei mai trebuie respectate i
principiile proiectrii interfeelor:
Simplitatea
Interfaa trebuie s fie ct mai uor de neles
31
i de nvat de ctre utilizator i s permit
acestuia s efectueze operaiile dorite n timp ct mai scurt. n acest sens, este vital
culegerea de informaii despre utilizatorii finali ai aplicaiei i a modului n care acetia sunt
obinuii s lucreze.
Poziia controalelor
Locaia controalelor dintr-o fereastr trebuie s reflecte importana relativ i frecvena de
utilizare. Astfel, cnd un utilizator trebuie s introduc nite informaii unele obligatorii i
altele opionale este indicat s organizm controalele astfel nct primele s fie cele care
preiau informaii obligatorii.
Consistena
Ferestrele i controalele trebuie s fie afiate dup un design asemntor (template) pe
parcursul utilizrii aplicaiei. nainte de a implementa interfaa, trebuie decidem cum va arta
aceasta, s definim template-ul.
Estetica
Intefaa trebuie s fie pe ct posibil plcut i atrgtoare.
4.2. Mediul de dezvoltare Visual C#
Mediul de dezvoltare Microsoft Visual C# dispune de instrumente specializate de
proiectare, ceea ce permite crearea aplicaiilor n mod interactiv, rapid i uor.
Pentru a construi o aplicaie Windows (FileNew Project) se selecteaz ca template
Windows Application.
O aplicaie Windows conine cel puin o fereastr (Form) n care se poate crea o
interfa cu utilizatorul aplicaiei.
Componentele vizuale ale aplicaiei pot fi prelucrate n modul Designer (Shift+F7)
pentru a plasa noi obiecte, a le stabili proprietile etc. Codul din spatele unei componente
vizuale este accesibil n modul Code (F7).
n fereastra Solution Explorer sunt afiate
toate fiierele 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 proprietile obiectelor.
Toolbox conine controale standard drag-
and-drop i componente utilizate n crearea aplicaiei
Windows. Controalele sunt grupate n categoriile
logice din imaginea alturat.
Designer, Code, Solution Explorer i celelalte se afl grupate n meniul View.
La crearea unei noi aplicaii vizuale, Visual Studio.NET genereaz un spaiu de nume
ce conine clasa static Program, cu metoda static ce constituie punctul de intrare (de
lansare) a aplicaiei:
static void Main()
{ ...
Application.Run(new Form1());
}
Clasa Application este responsabil cu administrarea unei aplicaii Windows, punnd la
dispoziie proprieti pentru a obine informaii despre aplicaie, metode de lucru cu aplicaia
i altele. Toate metodele i proprietile clasei Application sunt statice. Metoda Run invocat

31
ntruct mintea uman poate s perceap la un moment dat aproximativ 5-9 obiecte, o
fereastr supra-ncrcat de controale o face greu de utilizat.
mai sus creeaz un formular implicit, aplicaia rspunznd la mesajele utilizatorului pn
cnd formularul va fi nchis.
Compilarea modulelor aplicaiei i asamblarea lor ntr-un singur fiier executabil se
realizeaz cu ajutorul opiunilor din meniul Build, uzual fiind Build Solution (F6).
Odat implementat, aplicaia poate fi lansat, cu asisten de depanare sau nu
(opiunile Start din meniul Debug). Alte faciliti de depanare pot fi folosite prin umrirea pas
cu pas, urmrirea pn la puncte de ntrerupere etc. (celelalte opiuni ale meniului Debug).
Ferestre auxiliare de urmrire sunt vizualizate automat n timpul procesului de depanare, sau
pot fi activate din submeniul Windows al meniului Debug.
4.3. Ferestre
Spaiul Forms ne ofer clase specializate pentru: creare de ferestre 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 automat pe msur ce noi
desemnm componentele i comportamentul acesteia. n fapt, acest cod realizeaz:
derivarea unei clase proprii din System.Windows.Forms.Form, clas care este nzestrat
cu o colecie de controale (iniial vid). Constructorul ferestrei realizaz instanieri ale
claselor Button, MenuStrip, Timer etc. (orice plasm noi n fereastr) i adaug referinele
acestor obiecte la colecia de controale ale ferestrei.
Dac modelul de fereastr reprezint ferestra principal a aplicaiei, atunci ea este
instaniat automat n programul principal (metoda Main). Dac nu, trebuie s scriem noi
codul ce realizeaz instanierea.
Clasele derivate din Form motenesc o serie de proprieti care determin atributele
vizuale ale ferestrei (stilul marginilor, culoare de fundal, etc.), 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 permind ca revenirea n fereastra din care a fost activat 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 deinut.
Activarea propietarului unui formular deschis modal va determina activarea formularului
deschis modal. Cnd un nou formular este activat folosind form.Show() nu va avea nici un
deintor, 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. Deintorul se poate
stabili setnd proprietarul nainte s apelm Form.ShowDialog() sau apelnd
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 proprieti ale form-urilor, reamintim:
StartPosition determin poziia ferestrei atunci cnd aceasta apare prima dat, poziie
ce poate fi setat Manual sau poate fi centrat pe desktop (CenterScreen), stabilit de
Windows, formularul avnd dimensiunile i locaia stabilite de programator
(WindowsDefaultLocation) sau Windows-ul va stabili dimensiunea iniial i locaia
pentru formular (WindowsDefaultBounds) sau, centrat pe formularul care l-a afiat
(CenterParent) atunci cnd formularul va fi afiat modal.
Location (X,Y) reprezint coordonatele colului din stnga sus al formularului relativ la
colul stnga sus al containerului. (Aceast propietate e ignorat dac StartPosition =
Manual).
Micarea formularului ( i implicit schimbarea locaiei) poate fi tratat n evenimentele
Move i LocationChanged .
Locaia formularului poate fi stabilit relativ la desktop 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. Cnd se schimb propietile
Width i Height ale unui formular, acesta se va redimensiona automat, aceast
redimensionare fiind tratat n evenimentele Resize sau in SizeChanged.
Chiar dac propietatea Size a formularului indic dimensiunea ferestrei, formularul nu este
n totalitate responsabil pentru desenarea ntregului coninut al su. Partea care este
desenat de formular mai este denumit i Client Area. Marginile, titlul i scrollbar-ul sunt
desenate de Windows.
MaxinumSize i MinimumSize sunt utilizate pentru a restriciona 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 form-uri.
ControlBox precizeaz dac fereastra conine sau nu un icon, butonul de nchidere al
ferestrei i meniul System (Restore,Move,Size,Maximize,Minimize,Close).
HelpButton-precizeaz dac butonul va aprea sau nu lng butonul de nchidere al
formularului (doar dac MaximizeBox=false, MinimizeBox=false). Dac utilizatorul apas
acest buton i apoi apas oriunde pe formular va aprea evenimentul HelpRequested
(F1).
Icon reprezint un obiect de tip *.ico folosit ca icon pentru formular.
MaximizeBox i MinimizeBox precizeaz dac fereastra are sau nu butonul Maximize i
respectiv Minimize
Opacity indic procentul de opacitate
32

ShowInTaskbar precizeaz dac fereastra apare in TaskBar atunci cnd formularul este
minimizat.
SizeGripStyle specific tipul pentru Size Grip (Auto, Show, Hide). Size grip (n colul
din dreapta jos) indic faptul c aceast fereastr poate fi redimensionat.
TopMost precizeaz dac fereastra este afisat n faa tuturor celorlalte ferestre.
TransparencyKey identific o culoare care va deveni transparent pe form.

Definirea unei funcii de tratare a unui eveniment asociat controlului se realizeaz prin
selectarea grupului Events din ferestra Properties a controlului respectiv i alegerea
evenimentului dorit.
Dac nu scriem nici un nume pentru funcia de tratare, ci efectum dublu click n
csua respectiv, se genereaz automat un nume pentru aceast funcie, innd cont de
numele controlului i de numele evenimentului (de exemplu button1_Click).
Dac n Designer efectum dublu click pe un control, se va genera automat o funcie
de tratare pentru evenimentul implicit asociat controlului (pentru un buton evenimentul
implicit este Click, pentru TextBox este TextChanged, pentru un formular Load etc.).
Printre evenimentele cele mai des utilizate, se numr :
Load apare cnd formularul este pentru prima data ncrcat n memorie.

32
Dac va fi setat la 10% formularul i toate controalele sale vor fi aproape invizibile.

FormClosed apare cnd formularul este nchis.
FormClosing apare cnd formularul se va inchide ca rezultat al aciunii utilizatorului
asupra butonului Close (Dac se seteaz CancelEventArgs.Cancel =True atunci se
va opri nchiderea formularului).
Activated apare pentru formularul activ.
Deactivate apare atunci cnd utilizatorul va da click pe alt formular al aplicatiei.
4.4. Controale
Unitatea de baz a unei interfee Windows o reprezint un control. Acesta poate fi
gzduit de un container ce poate fi un formular sau un alt control.
Un control este o instan a unei clase derivate din System.Windows.Forms i este
reponsabil cu desenarea unei pri din container. Visual Studio .NET vine cu o serie de
controale standard, disponibile n Toolbox. Aceste controale pot fi grupate astfel:
Controale de actiune (de exemplu button) care, atunci cnd sunt acionate, se poate
executa o prelucrare. De exemplu, cel mai important eveniment pentru Button este Click
(desemnnd aciunea click stnga pe buton).
n exemplul PV1 se adaug pe formular dou butoane i o caset
text. Apsarea primului buton va determina afiarea textului din TextBox
ntr-un MessageBox iar apsarea celui de-al doilea buton va nchide
nchide aplicaia. Dup adugarea celor dou butoane i a casetei text a
fost schimbat textul afiat pe cele dou butoane au fost scrise funciile
de tratare a evenimentului Click pentru cele dou butoane:
private void button1_Click(object sender, System.EventArgs e)
{ MessageBox.Show(textBox1.Text);}
{ Form1.ActiveForm.Dispose();}
Controale valoare (label, textbox, picturebox) care arat utilizatorului o informaie
(text, imagine).
Label este folosit pentru plasarea de text pe un formular. Textul afiat este coninut n
propietatea Text i este aliniat conform propietii TextAlign.
TextBox - permite utilizatorului s introduc un text. Prevede, prin intermediul
ContextMenu-ului asociat, un set de funcionaliti de baz, ca de exemplu (Cut,
Copy, Paste, Delete, SelectAll).
PictureBox permite afiarea unei imagini.
Exemplul PV2 afieaz un grup alctuit din 3
butoane, etichetate A,B respectiv C avnd iniial
culoarea roie. Apsarea unui buton determin
schimbarea culorii acestuia n galben. La o nou
apsare butonul revine la culoare iniial. Acionarea
butonului Starea butoanelor determin afiarea ntr-o
caset text a etichetelor butoanelor galbene. Caseta
text devine vizibil atunci cnd apsm prima oar
acest buton. Culoarea butonului mare (verde/portocaliu)
se schimb atunci cnd mouse-ul este poziionat pe
buton.
Dup adugarea butoanelor i a casetei text pe
formular, stabilim evenimentele care determin
schimbarea culoriilor i completarea casetei text.
{if (button1.BackColor== Color.IndianRed) button1.BackColor=Color.Yellow;
else button1.BackColor= Color.IndianRed;}
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;}
{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';
}
Exerciiu Modificai aplicaia precedent astfel nct s avem un singur eveniment
button_Click, diferenierea fiind fcut de parametrul sender.
Exerciiu ( Password) Adugai pe un formular o caset text n care s introducei un
ir de caractere i apoi verificai dac acesta coincide cu o parol dat. Textul introdus n
caset nu este vizibil (fiecare caracter este nlocuit cu*). Rezultatul va fi afiat ntr-un
MessageBox.
Controale de selecie (CheckBox,RadioButton) au propietatea Checked care indic
dac am selectat controlul. Dup schimbarea strii unui astfel de control, se declaneaz
evenimentul Checked. Dac propietatea ThreeState este setat, atunci se schimb
funcionalitatea acestor controale, n sensul c acestea vor permite setarea unei alte
stri. n acest caz, trebuie verificat propietatea CheckState(Checked,
Unchecked,Indeterminate) pentru a vedea starea controlului.
Aplicaia PV3 este un exemplu de utilizare a
acestor controale. Soluia unei probleme cu
mai multe variante de rspuns este memorat
cu ajutorul unor checkbox-uri cu proprietatea
ThreeState. Apsarea butonului Verific
determin afiarea unei etichete i a
butoanelor radio DA i NU. Rspunsul este afiat ntr-un MessageBox.
Dup adugarea controalelor pe formular i setarea proprietilor Text i ThreeState n
cazul checkbox-urilor stabilim evenimentele click pentru butonul 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 &&
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;}
{label2.Visible=true;radioButton1.Visible=true;radioButton2.Visible=true;}
Exerciiu (Test gril) Construii un test gril care conine 5 itemi cu cte 4 variante de
rspuns (alegere simpl sau multipl), memorai rspunsurile date i afiai, dup efectuarea
testului, ntr-o caset text, n dreptul fiecrui item, rspunsul corect.
LinkLabel afieaz un text cu posibilitatea ca anumite pri ale textului (LinkArea) s fie
desenate ca i hyperlink-uri. Pentru a face link-ul funcional trebuie tratat evenimentul
LinkClicked.
n exemplul PV4, prima etichet permite afiarea coninutului discului C:, a doua legtur
este un link ctre pagina www.microsoft.com/romania i a treia acceseaz Notepad.


private void etichetaC_LinkClicked (object sender,
LinkLabelLinkClickedEventArgs e )
{ etichetaC.LinkVisited = true;
System.Diagnostics.Process.Start( @"C:\" );}
private void etichetaI_LinkClicked( object sender,
{etichetaI.LinkVisited = true;
System.Diagnostics.Process.Start("IExplore",
"http://www.microsoft.com/romania/" );}
private void etichetaN_LinkClicked( object sender,
{etichetaN.LinkVisited = true;
System.Diagnostics.Process.Start( "notepad" );}
Exerciiu (Memorator) Construii o aplicaie care s conin patru legturi ctre cele
patru fiiere/ pagini care conin rezumatul capitolelor studiate.
Controale pentru listare (ListBox, CheckedListBox, ComboBox, ImageList) ce pot fi
legate de un DataSet, de un ArrayList sau de orice tablou (orice surs de date ce
implementeaz interfaa IEnumerable).
n exemplul PV5 elementele selectate din
CheckedListBox se adaug n ListBox. Dup
adugarea pe formular a CheckedListBox-ului,
stabilim colecia de itemi (Properties-Items-
Collection), butonul Selecie i ListBox-ul.
Evenimentul Click asociat butonului Setectie golete
mai nti listBox-ul (listBox1.Items.Clear();) i
dup aceea adaug n ordine fiecare element
selectat din CheckedListBox. Suplimentar se afieaz
o etichet cu itemii selectai.

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;}
Exerciiu ( Filtru) Construii o aplicaie care afieaz fiierele dintr-un folder ales care
au un anumit tip ( tipul fiierelor este ales de utilizator
pe baza unui CheckedListBox)
Aplicaia PV6 este un exemplu de utilizare a
controlului ImageList. Apsarea butonului Desene va
aduga fiierele *.gif din folderul C:\Imagini n list i va
afia coninutul acesteia. Butonul Animate va determina
afiarea fiierelor *.gif cu ajutorul PictureBox.
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();
}
Exerciiu (Thumbnails) Afiai ntr-o ferestr coninutul folder-ului curent n mod View-
Thumbnails.
MonthCalendar afieaz un calendar prin care se poate selecta o dat (zi, luna, an) n
mod grafic. Proprietile mai importante sunt: MinDate, MaxDate, TodayDate ce
reprezint data minim/maxim selectabil i data curent (care apare afiat difereniat
sau nu n funcie de valorile proprietilor 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 obiect de tipul
DateRangeEventArgs care conine proprietile Start i End (reprezentnd intervalul de
timp selectat).
Formularul din aplicaia PV7 conine un
calendar pentru care putem selecta un interval de
maximum 30 de zile, sunt afiate sptmnile i
ziua curent. Intervalul selectat se afieaz prin
intermediul unei etichete. Dac se selecteaz o
dat atunci aceasta va fi adugat ca item ntr-un
ComboBox (orice dat poate aprea cel mult o
dat n list).
Dup adugarea celor 3 controale pe formular, stabilim proprietile pentru
monthCalendar1 (ShowWeekNumber-True, MaxSelectionCount-30, etc.) i precizm ce
se execut atunci cnd selectm 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 pentru a
selecta o dat. La click se afieaz un control de tip MonthCalendar, prin care se poate
selecta data dorit. Fiind foarte asemntor cu MonthCalendar, proprietile prin care se
poate modifica comportamentul controlului sunt identice cu cele ale controlului
MonthControl.
Exerciiu (Formular) Contruii un formular de introducere a datelor necesare realizrii
unei adrese de e-mail. Data naterii va fi selectat direct utiliznd MonthCalendar.
ListView este folosit pentru a afia o colecie de elemente n unul din cele 4 moduri
(Text, Text+Imagini mici, Imagini mari, Detalii). Acesta este similar grafic cu
ferestrele n care se afieaz fiierele dintr-un anumit director din Windows Explorer.
Fiind un control complex, conine foarte multe proprieti, printre care:
View ( selecteaz modul de afiare (LargeIcon, SmallIcon, Details, List)),
LargeImageList, SmallImageList (icon-urile de afiat n modurile LargeIcon,
SmallIcon), Columns(utilizat doar n modul Details, pentru a defini coloanele de
afiat), Items(elementele de afiat).

Aplicaia PV8 este un exemplu de utilizare
ListView. Se pornete de la rdcin i se
afieaz coninutul folder-ului selectat cu dublu
click. La expandare se afieaz numele complet,
data ultimei accesri i, n cazul fiierelor,
dimensiunea.
Controlul lista_fisiere este de tip ListView.
Funcia ConstruiesteHeader permite
stabilirea celor trei coloane de afiat.

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 afieaz mai nti folderele i dup aceea fiierele. Pentru aceasta
trebuie s determinm coninutul 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 coninut al listei:
this.lista_fisiere.Items.Clear();
this.lista_fisiere.BeginUpdate();
i s adugm fiecare nou item ( coloana a doua este vid n cazul 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);
}
Exerciiu (Ordonare) Modificai aplicaia anterioar astfel nct apsarea pe numele
unei coloane s determine afiarea informaiilor ordonate dup criteriul specificat (nume,
dimensiune, data).
Controale de control al executrii (Timer) sau de dialog (OpenFileDialog,
SaveFileDialog, ColorDialog, FontDialog, ContextMenu).
Grupuri de controale Toolbar (ToolStrip) afieaz o bar de butoane n partea de sus a
unui formular. Se pot introduce vizual butoane (printr-un designer, direct din Visual
Studio.NET IDE), la care se pot seta att textul afiat sau imaginea. 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 aplicaia urmtoare PV9 cele 3 butoane ale
toolbar-ului permit modificarea proprietilor textului
introdus n caset. Toolbar-ul se poate muta fr a depi
spaiul 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 cnd apsm butonul de
mouse i/sau ne deplasm pe suprafaa 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;
}}}
}
Exerciiu (Editor) Realizai un editor de texte care conin un control toolBar cu butoanele
uzuale.
Controale container (GroupBox, Panel, TabControl) sunt controale ce pot conine alte
controale.
Aplicaia PV10 simuleaz lansarea unei
comenzi ctre un magazin de jucrii. Se utilizeaz 4
pagini de Tab pentru a simula selectarea unor opiuni
ce se pot grupa pe categorii.
Exerciiu (Magazin) Dezvoltai aplicaia
precedent astfel nct pe o pagin s se afieze
modelele disponibile (imagine+detalii) i s se
permit selectarea mai multor obiecte. Ultima pagin
reprezint coul de cumprturi.
Grupuri de controale tip Meniu (MenuStrip, ContextMenuStrip etc.)
Un formular poate afia un singur meniu principal la un moment dat, meniul asociat
iniial fiind specificat prin propietatea Form.MainMenuStrip. Meniul care este afiat de ctre
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 utiliznd Menu Designer. Clasa MenuStrip are o colecie de MenuItem
care conine 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).
Propietile Checked si RadioCheck indic itemul selectat, Enabled and Visible
determin dac un item poate fi sau nu selectat sau vizibil, Shortcut permite asignarea unei
combinaii de taste pentru selectarea unui item al meniului i Text memoreaz textul care va
fi afiat pentru respectivul item al meniului.
Evenimentul Click are loc cnd un utilizator apas un item al meniului.
Exemplul PV11 permite, prin
intermediul unui meniu, scrierea unui fisier
Notpad, afiarea continutului acestuia ntr-
o caset text, schimbarea fontului i culorii
de afiare, tergerea coninutului casetei,
afiarea unor informaii teoretice precum i
Help dinamic. Au fost definite chei de
acces rapid pentru accesarea
componentelor meniului.
File New permite scrierea unui fiier notepad nou
System.Diagnostics.Process.Start( "notepad" );
File Open selecteaz i afieaz n caseta text coninutul unui fiier 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 coninutul casetei text, File Exit nchide aplicaia
Window Font i Window Color permit stabilirea fontului/culorii textului afiat.
Help DinamicHelp acceseaz System.Diagnostics.Process.Start("IExplore",
"http://msdn2.microsoft.com/en-us/default.aspx");
Help About PV afieaz n caseta text informaii despre implementarea unui menu.
Exerciiu (Fisiere) Contruii un menu care s permit efectuarea operaiilor uzuale cu fiiere.
4.5. System.Drawing
Spaiul System.Drawing conine tipuri care permit realizarea unor desene 2D i au
rol deosebit n proiectarea interfeelor grafice.
Un obiect de tip Point este reprezentat prin coordonatele unui punct ntr-un spaiul
bidimensional (exemplu: Point myPoint = new Point(1,2);)
Point este utilizat frecvent nu numai pentru desene, ci i pentru a identifica n program
un punct dintr-un anumit spaiu. De exemplu, pentru a modifica poziia unui buton n
fereastr putem asigna un obiect de tip Point proprietii Location indicnd astfel poziia
colului din stnga-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 conine date, tipuri i metode utile n lucrul cu culori. Fiind un tip
valoare (struct) i nu o clas, aceasta conine date i metode, ns nu permite instaniere,
constructori, destructor, motenire.
Color myColor = Color.Brown; button1.BackColor = myColor;
Substructura FromArgb a structurii Color returneaz o culoare pe baza celor trei
componente ale oricrei culori (red, green, blue).
Clasa Graphics este o clas sigilat reprezentnd o arie rectangular care permite
reprezentri grafice. De exemplu, o linie frnt se poate realiza 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);

Aplicaia PV12 este un exerciiu 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 construiete 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);}
4.6. Validarea informaiilor de la utilizator
nainte ca informaiile de la utilizator s fie preluate i transmise ctre alte clase, este
necesar s fie validate. Acest aspect este important, pentru a preveni posibilele erori. Astfel,
dac utilizatorul introduce o valoare real (float) cnd aplicaia ateapt un ntreg (int), este
posibil ca aceasta s se comporte neprevzut abia cteva secunde mai trziu, i dup multe
apeluri de metode, fiind foarte greu de identificat cauza primar a problemei.
Validarea la nivel de cmp
Datele pot fi validate pe msur 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 situaii (de exemplu atunci cnd valorile introduse trebuie s se afle ntr-o
anumit relaie ntre ele), validarea se face la sfritul introducerii 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.
Urmrii aplicaiile i precizai pentru fiecare dintre ele controalele utilizate,
evenimentele tratate: Forma poloneza (PV14), Triunghi (PV15), Ordonare vector(PV16),
Subsir cresctor de lungime maxim(PV17), Jocul de Nim (PV18)
Exerciiu (Test grila) Realizai un generator de teste gril (ntrebrile sunt preluate
dintr-un fisier text, pentru fiecare item se precizeaz punctajul, enunul, rspunsul corect,
distractorii i o imagine asociat enunului (dac exist). Dup efectuarea testului se
afieaz rezultatul obinut i statistica rspunsurilor.
5. Aplicaii orientate pe date
5.1. Structuri de date
Construirea unei aplicaii ce gestioneaz un volum mare de date necesit o atenie
particular privind organizarea acestor date. Sursele de date trebuie i ele integrate
corespunztor ntr-o aplicaie 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
operaiile executate de o aplicaie ce monitorizeaz traficul dintr-o gar de triaj, este
important de tiut dac trebuie memorat sau nu un istoric al acestor operaii, dac sunt
folosite informaiile de acest tip n prelucrri ulterioare sau sunt doar listate sub form de
rapoarte periodice, etc. Dac datele trebuie exportate ctre alte aplicaii, atunci se pune
problema formatului n care vor fi salvate. Pentru coleciile consistente de date care sufer
prelucrri ample i frecvente se pune problema suportului de memorare astfel nct s
suporte tehnici de acces rapide etc.
5.2. Colecii de date
Colecia, n general, reprezint un ansamblu bine structurat de componente de acelai
tip, ansamblu ce permite identificarea rapid a oricrei componente din colecie. Definiia
este aplicabil i coleciilor de date. Uneori, cloeciile de date sunt percepute ca date externe
(aflate pe harddisc sau alte suporturi de memorare), dar asta nu exclude posibilitatea
organizrii datelor interne sub forma unor colecii. n C#, coleciile sunt clase specializate
aparinnd spaiului System.Collection. Despre colecii am mai vorbit n cadrul capitolului 3.11.
Aducem unele completri n cele ce urmeaz vorbind despre structuri generice de date.
Atributul generic se refer la proprietatea de a referi o ntreag categorie de obiecte.
Clasele, structurile, metodele, interfeele, delegaii i metodele pot fi generice, adic pot fi
concepute astfel nct s depind de unul sau mai multe tipuri de date pe care acestea le
memoreaz sau manipuleaz.
De exemplu, la declararea unei clase obinuite, noi stabilim elementele fixe ale
acesteia: numele i tipurile datelor, numele metodelor
33
i altor componente ce formeaz
clasa respectiv. Pentru o funcie (metod) obinuit sunt definite att numele, ct i tipul
parametrilor funciei
34
.
C# introduce, ncepnd de la versiunea 2.0, parametrizarea tipurilor, adic posibilitatea
declarrii unor clase, metode etc. n care tipul datelor manevrate nu este cunoscut dect la
apel. Acest tip de date constituie un parametru al clasei, metodei etc.
Vom defini n mod obinuit i, paralel, n mod generic clasa Stiva (amintit i n
capitolul 1.1) pentru a pune n eviden diferenele 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]);
}
}
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]);
}
}

33
A nu se confunda capacitatea de a defini mai multe metode cu acelai 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
Numrul parametrilor este i el bine definit, dei funciile care au definit un parametru de tip
tablou, permit apelul cu un numr variabil de parametri efectivi.
35
Versiuni mai vechi de C nu execut conform ateptrilor returul valorii cu postincrementare.
Aplicaii orientate pe date 39
...
{
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();
}
...
{
Stiva<int> s = new Stiva<int>();
s.Push(7); s.Push(5); s.scrie();
s.scrie();
s.Push(7); s.scrie();
s.scrie();
}
Dintre clasele generice predefinite, cele mai des utilizate sunt coleciile generice.
Astfel, clasele i interfeele din spaiul System.Collection.Generic permit organizarea
datelor proprii, indiferent de tipul acestora, n structuri specifice cum ar fi: liste (List), liste
dublu nlnuite (LinkedList), stive (Stack), cozi (Queue), dicionare (Dictionary) etc.
De exemplu, dorim s gestionm un ansamblu de ferestre asemntoare, instaniate
dintr-o aceeai 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 oricrei ferestre f de tipul MyForm (MyForm f=new MyForm(); f.Show();)
se adaug referina ferestrei n lista fer (fer.Add(f)). Analog, la nchiderea ferestrei, se va
elimina referina acesteia din list (fer.Remove(f)).
Exerciiu: Presupunem c implementm o aplicaie n care se completeaz datele
unui pacient ntr-o fereastr. Pentru a nu ncrca ferestra curent, aceasta este proiectat s
conin butoane ce permit deschiderea unor ferestre secundare pentru completarea unor
subcategorii de date (istoricul suferinelor cronice, analize efectuate, adresa detaliat etc.).
De exemplu, n fereastr se completeaz numele pacientului, iar apoi, apsnd pe butonul
Adresa, se deschide o fereastr ce permite completarea cmpurilor ce formeaz adresa, la
nchiderea ferestrei revenind la fereastra principal. Desigur, i o fereastr secundar poate
avea la rndul ei butoane pentru alte ferestre secundare n raport cu aceasta. Stabilii ce tip
de structur generic se poate utiliza pentru gestiunea ferestrelor deschise la un moment
dat
36
.
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 fiier text, un fiier Excel sau XML, o baz de date Dbase, 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 att pentru lucrul n stil deconectat ct i conectat,
ofer instrumentele de utilizare i reprezentare XML, de combinare a datelor din diferite
surse i de diferite tipuri (pe baz mecanismenlor de reprezentare comun implementate de
.NET. Maniera de lucru deconectat recomand metoda ca fiind mai eficient n proiectarea
aplicaiilor pentru Internet dect alte tehnologii cum ar fi ADO sau ODBC.
Deoarece exist mai multe tipuri de baze de date e nevoie de cte o bibliotec
specializat de clase i interfee care s implementeze un protocol specific pentru fiecare.
5.4. Conectarea la o surs de date
nainte de orice operaie cu o surs de date extern, trebuie realizat o conexiune
(legtur) cu acea surs. Clasele din categoria Connection (SQLConnection,
OleDbConnection etc.) conin date referitoare la sursa de date (locaia, numele i parola
contului de acces, etc.), metode pentru deschiderea/nchiderea conexiunii, pornirea unei
tranzacii etc. Aceste clase se gsesc n subspaii (SqlClient, OleDb etc.) ale spaiului
System.Data. n plus, ele implementeaz interfaa IDbConnection.

36
punem accentul pe faptul c ferestrele sunt modale
Pentru deschiderea unei conexiuni prin program se poate instania un obiect de tip
conexiune, precizndu-i ca parametru un ir de caractere coninnd date despre conexiune.
Dm 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();
...
Proprietile unei conexiuni
ConnectionString (String): conine un string cu o succesiune de parametri de forma
parametru=valoare, desprii prin ;. Parametrii pot fi:
provider: specific furnizorul de date pentru conectarea la sursa de date. Acest furnizor
trebuie precizat doar dac se folosete OLE DB .NET Data Provider, i nu se specific
pentru conectare la SQL Server
Data Source: se specific numele serverului de baze de date sau numele fiierului de date
Initial Catalog (Database): specific numele bazei de date. Baza de date trebuie s se
gseasc pe serverul dat n Data Source.
User ID: specifica un nume de cont de utilizator care are acces de logare la server.
Password: specific parola contului de mai sus.
ConnectionTimeout (int): specific numrul de secunde pentru care un obiect de
conexiune poate s atepre pentru realizarea conectrii la server nainte de a se genera o
excepie. (implicit 15). Se poate specifica o valoare diferit de 15 n ConnectionString
folosind parametrul Connect Timeout, Valoarea Timeout=0 specific ateptare 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 sa fcut conectarea. Este
necesar pentru a arta unui utilizator care este baza de date pe care se face operarea
Provider (string): returneaz furnizorul
ServerVersion (string): returneaz versiunea de server la care sa fcut conectarea.
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 pentru ea
BeginTransaction(): pentru executarea unei tranzacii pe baza de date; la sfrit se
apeleaz Commit() sau Rollback().
ChangeDatabase(): se modific baza de date la care se vor face conexiunile. Noua baz
de date trebuie s existe pe acelai server ca i precedenta.
CreateCommand(): creeaz o comand (un obiect de tip Command) valid asociat
conexiunii curente.
Evenimentele unei conexiuni
StateChange: apare atunci cnd se schimb starea conexiunii. Handlerul corespunztor (de
tipul delegat StateChangeEventHandler) spune ntre ce stri s-a fcut tranziia.
InfoMessage: apare cnd furnizorul trimite un avertisment sau un mesaj ctre client.
5.5. Executarea unei comenzi SQL
Clasele din categoria Command (SQLCommand, OleDbCommand etc.) conin date
referitoare la o comand SQL (SELECT, INSERT, DELETE, UPDATE) i metode pentru
executarea unei comenzi sau a unor proceduri stocate. Aceste clase implementeaz
interfaa IDbCommand. Ca urmare a interogrii unei baze de date se obin obiecte din
categoriile DataReader sau DataSet. O comand se poate executa numai dup ce s-a
stabilit o conxiune cu baza de date corespunztoare.
SqlConnection co = new SqlConnection(@"Data Source=serverBD;
Database=scoala;User ID=elev;Password=madonna");
co.Open();
SqlCommand cmd = new SqlCommand("SELECT * FROM ELEVI", con);
Proprietile unei comenzi
CommandText (String): conine comanda SQL sau numele procedurii stocate care se
execut pe sursa de date.
CommandTimeout (int): reprezint numrul de secunde care trebuie s fie ateptat pentru
executarea comenzii. Dac se depeste acest timp, atunci se genereaz o excepie.
CommandType (enumerare de componente de tip CommandType): reprezint tipul de
comand care se execut pe sursa de date. Valorile pot fi: StoredProcedure (apel de
procedur stocat), Text (comand SQL obinuit), TableDirect (numai pentru OleDb)
Connection (System. Data. [Provider].PrefixConnection): conine obiectul de tip conexiune
folosit pentru legarea la sursa de date.
Parameters (System.Data.[Provider].PrefixParameterCollection): returneaz o colecie de
parametri care s-au transmis comenzii;
Transaction (System.Data.[Provider].PrefixTransaction): permite accesul la obiectul de tip
tranzacie 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() oprete 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 returneaz numrul de
nregistrri afectate.
SqlCommand cmd = new SqlCommand();
cmd.CommandText = "DELETE FROM elevi WHERE nume = BARBU";
cmd.Connection = con;
Console.WriteLine(cmd.ExecuteNonQuery().ToString()); //cte 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 opional, CommandBehavior care descrie
rezultatele i efectul asupra bazei de date: CloseConnection (conexiunea este nchis atunci
cnd obiectul DataReader este nchis), KeyInfo (returnez informaie despre coloane i cheia
primar), SchemaOnly (returnez doar informaie despre coloane), SequentialAccess (pentru
manevrarea valorilor binare cu GetChars() sau GetBytes()), SingleResult (se returneaz un
singur set de rezultate), SingleRow (se returneaz o singur linie).
ExecuteScalar() execut comanda i returneaz valoarea primei coloane de pe primul
rnd a setului de date rezultat; folosit pentru obinerea 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 obinut prin interogare
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 obiecte din categoria
DataReader), sau pot fi preluate de la surs (dintr-un obiect din categoria DataAdapter) i
nglobate n aplicaia curent (sub forma unui obiect din categoria DataSet).
Clasele DataReader permit parcurgerea ntr-un singur sens a sursei de date, fr
posibilitate de modificare a datelor la surs. Dac se dorete modificarea datelor la surs, se
va utiliza ansamblul DataAdapter + DataSet.
Un obiect DeatReader nu are constructor, ci se obine cu ajutorul unui obiect de tip
Command i prin apelul metodei ExecuteReader() (vezi exemplul de la pagina 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
interfaa IDataReader.
Proprieti:
IsClosed, HasRows, Item (indexator de cmpuri) i FieldCount
Metode:
Close() nchidere obiectului i eliberarea resurselor; trebuie s precead nchiderea conxiunii
GetBoolean(), GetByte(), GetChar(), GetDateTime(), GetDecimal(),
GetDouble(), GetFloat(), GetInt16(), GetInt32(), GetInt64(), GetValue(),
GetString() returneaz valoarea unui cmp specificat, din nergistrarea curent
GetBytes(), GetChars() citirea unor octei/caractere dintrun cmp de date binar
GetDataTypeName(), GetName() returneaz tipul/numele cmpului specificat
IsDBNull() returneaz true dac n cmpul specificat prin index este o valoare NULL
NextResult()determin trecerea la urmtorul rezultat stocat n obiect (vezi exemplul)
Read() determin trecerea la urmtoarea nregistrare, returnnd false numai dac aceasta
nu exist; de reinut c iniial poziia curent este naintea primei ntrgistrri.
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 operaii de selectare,
tergere, modificare i adugare la baza de date. Clasele DataAdapter genereaz obiecte
care funcioneaz ca o interfa ntre sursa de date i obiectele DataSet interne aplicaiei,
permind prelucrri pe baza de date. Ele gestioneaz automat conexiunea cu baza de date
astfel nct conexiunea s se fac numai atunci cnd este imperios necesar.
Un obiect DataSet este de fapt un set de tabele relaionate. Folosete serviciile unui
obiect DataAdapter pentru a-i procura datele i trimite modificrile napoi ctre baza de date.
Datele sunt stocate de un DataSet n format XML, acelai folosit i pentru transferul datelor.
n exemplul urmtor 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
Proprietile unui DataAdapter
DeleteCommand, InsertCommand, SelectCommand, UpdateCommand (Command),
conin comenzile ce se execut pentru selectarea sau modificarea datelor n sursa de date.
MissingSchemaAction (enumerare) determin ce se face atunci cnd datele aduse nu se
potrivesc peste schema tablei n care sunt depuse. Poate avea urmtoarele valori:
Add - implicit, DataAdapter adaug coloana la schema tablei
AddWithKey se adug coloana i informaii relativ la cheia primar
Ignore - se ignor lipsa coloanei respective, ceea ce duce la pierdere de date
Error - se genereaz o excepie de tipul InvalidOperationException.
Metodele unui DataAdapter
Constructoril: SqlDataAdapter(); sau SqlDataAdapter(obiect_comanda); sau
SqlDataAdapter(string_comanda, conexiune);
Fill() permite umplerea unei tabele dintrun obiect DataSet cu date. Permite specificarea
obiectului DataSet n care se depun datele, eventual a numelui tablei din acest DataSet,
numrul de nregistrare cu care s se nceap popularea (prima avnd indicele 0) i numrul
de nregistrri care urmeaz a fi aduse.
Update() permite transmiterea modificrilor efectuate ntrun DataSet ctre baza de date.
Structura unui DataSet
Un DataSet este format din Tables (colecie format din obiecte de tip DataTable; DataTable
este compus la rndul lui dintr-o colecie de DataRow i DataColumn), Relations (colecie de
obiecte de tip DataRelation pentru memorarea legturilor printecopil) i ExtendedProperties
ce conine proprieti definite de utilizator.
Scenariul uzual de lucru cu datele dintr-o tabel conine urmtoarele etape:
popularea succesiv a unui DataSet prin intermediul unuia sau mai multor obiecte
DataAdapter, apelnd 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 corespunztoare operaiilor INSERT,
UPDATE i DELETE. Un obiect CommandBuilder poate construi automat o
combinaie de comenzi ce reflect modificrile efectuate.
5.7. Proiectarea vizual a seturilor de date
Mediul de dezvoltare Visual Studio dispune de instrumente puternice i sugestive
pentru utilizarea bazelor de date n aplicaii. Conceptual, n spatele unei ferestre n care
lucrm 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 urmrim un scenariu de realizare a unei aplicaii simple cu o
fereastr n care putem vizualiza date dintr-o tabel, putem naviga,
putem modifica sau terge nregistrri.
Iniiem adugarea unei surse de date (Add New Source)
Configurm cu atenie (asistai de vrjitor) 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.
Selectm tabelele care ne intereseaz din baza de date i
cmpurile din cadrul tabelei ce vor fi reinute n TableAdapter
(din categoria DataAdapter)
Cnd operaiunea se ncheie, date relative la baza de date la
care ne-am conectat sunt integrate n proiect i pictograma, ca
i structura bazei de date apar n fereastra Data Source

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 instaniere, construirea
barei de navigare ce permite
operaii de deplasare, editare,
tergere i adugare n tabel.

S observm c reprezentarea vizual a fiecrui obiect este
nzestrat cu o sget n partea de sus, n dreapta. Un click
pe aceast sgeat activeaz un meniu contextual cu lista
principalelor operaii ce se pot efectua cu obiectul respectiv.
Meniul contextual asociat grilei n care vor fi vizualizate datele
permite configurarea modului de lucru cu grila (sursa de date,
operaiile permise i altele).

n timpul rulrii aplicaiei,
bara de navigare i elementele
vizuale ale grilei permit operaiile
de baz cu nregistrrile bazei
de date. Operaiile 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. APLICAII ORIENTATE SPRE SERVICII ........................................................................................... 54
2. PROTOCOALE DE REEA....................................................................................................... 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 APLICAII WEB FOLOSIND ASP.NET..................................................................... 78
4.3.1. Configurarea masinii de lucru pentru proiecte ASP.NET.................................................. 78
4.3.2. Proiectele ASP.NET in Visual 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 informatiilor ...................................................................................................... 81
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 poate 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 importanta deosebita in acest
proces, deoarece alegerile facute aici determina derularea viitoarelor etape, implicit limitele
intre care se va programa efectiv aplicatia. Arhitectura este un 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 de calculatoarele dntr-o
reea. Arhitectura software client-server este o infrastructur modular, bazat pe mesaje.
Un client este definit ca un solicitant de servicii, iar serverul ca un prestator de servicii. O
masin (un calculator) poate fi in acelai timp att client ct i server n funcie de aplicaiile
rulate.
Precursoare ale modelului client-server au fost arhitecturile de 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 arhitectural client-server, ci tot
cu modul in care erau utilizate calculatoarele. In plus, sunt si niste erori in exprimare, cum ar
fi Comunicarea ntre client i server se realizeaz prin intermediul interogarilor SQL sau a
RPC (Remote Procedure Calls). Una este SQL si cu totul altceva este RPC nu prea au
legatura.
n arhitectura mainframe aplicaiile rulau pe un computer principal, iar utilizatorii
interacionau cu acesta prntr-un terminal (blind terminal) care trimitea informaiile tastate.
Limitarile acestui tip de arhitectur constau n faptul c nu asigurau o interfat grafica cu
utilizatorul (GUI) si nu puteau accesa baze de date distribuite in diferite locaii.
Reelele de calculatoare iniiale se bazau pe arhitectura de tip partajare de fisiere
(file-sharing) , n care serverul download-a fisiere (dntr-o locaie partajata) pe calculatorul
gazda. Aici se rulau aplicaiile (datele si procesarea lor). Viteza de lucru era scazut, iar
numarul maxim de utilizatori, care accesa simultan resursele partajate, era mic.
Ca urmare a limitrilor arhitecturii de tip file-sharing, a aparut modelul client server,
n care serverul de fisiere a fost inlocuit de un server de baze 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 returnarea unui raspuns la o
interogare, fa de returnarea unui ntreg fisier. Apar si interfatele grafice (GUI) pentru
52 Programare Web (suport de curs)
accesul la baza de date partajata (interfee numite i front-end). Comunicarea ntre client i
server se realizeaz prin intermediul interogarilor SQL sau a RPC (Remote Procedure Calls).

Mecanismul RPC a aparut cu mai bine de doua decenii in urma in lumea Unix si este
folosit in construcia de aplicaii distribuite pe sisteme eterogene, avand la baza tehnologiile
Internet. O aplicatie RPC va consta dintr-un client si un server, serverul fiind localizat pe
maina care execut procedura. Aplicaia client comunica prin reea via TCP/IP cu
procedura de pe calculatorul aflat la distan, transmind argumentele i recepionnd
rezultatele. Clientul i serverul se execut ca dou procese separate care pot rula pe
calculatoare diferite din reea.
In loc de ultimele 4 paragrafe, as insista mai mult pe niste modele 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 comunicam prin
acest serviciu. Server-ul (in acest caz programul server este instalat de fapt
mai multe masini) este programul central care:
o Are baza de date a utilizatorilor, adica a celor care au conturi de
Windows Live.
o Primeste mesaje de la clienti si le ruteaza, adica le trimite mai
departe catre clientul / clientii (in cazul unei conferinte) destinatari.
o Tine evidenta sesiunilor clientilor, adica stie tot timpul cand cineva
este logged in, cu Live Messenger pornit, respectiv cand iese.
o Etc.
Solutiile de email, cum ar fi de exemplu serverul Exchange + Outlook.

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

In astfel de arhitecturi, este usor de separat anumite functionalitati care nu ar trebui
s depinda unele de altele. De exemplu, interfata cu utilizatorul, 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-
server
nu este nevoie s avem cod care lucreaza cu baza de date. Astfel, se realizeaza o separare
logica benefica pentru intelegerea mai usoara si intretinerea mai eficienta a software-ului.
De exemplu, putem avea arhitecturi multi-strat pe 2 nivele (two tier architecture), in
care s spunem ca interfaa cu utilizatorul este situat pe calculatorul utilizatorului sub forma
unei aplicatii Windows (deci instalata pe calculator), iar sistemul 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 datelor 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. Interfaa 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 independent de celelalte. Spre exemplu
schimbarea sistemului de operare din Windows n Linux poate afecta doar modulul de
interfa.
De obicei, interfaa cu utilizatorul ruleaz pe un alt calculator i folosete 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 server 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 architecture).

Cele 3 nivele sunt:
Nivelul de prezentare (presentation tier) sau interfaa cu utilizatorul:
prezentarea rezultatelor sistemului catre utilizator si preluarea de informatii de
la utilizator
Nivelul logic de procesare (logic tier / business logic tier/ transaction tier) :
funcionalitatea specific aplicaiei.
Nivelul de date (data tier): Interactiunea cu suportul datelor (baze de date, fisiere,
servicii web, etc).

1.3. Aplicaii 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 definitie 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 interconectate care suporta
modelarea proceselor de business si a necesitatilor utilizatorilor. Resursele aflate ntr-o
retea sunt expuse ca servicii independente care pot fi accesate fara cunostiinte apriori
despre ceea ce rezida in spatele lor: platforma, implementare, algoritmi, etc.
Aceste concepte generice sunt valabile fie ca se vorbeste despre business-uri,
software sau alte tipuri de sisteme de tip consumator-producator.
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 independente, 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 prealabil 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 pentru care a fost definit.
Putem astfel incerca s definim SOA ca fiind: o paradigma pentru organizarea si
utilizarea capabilitatilor distribuite care pot s fie sub controlul unor entitati diferite. Aceasta
paradigma ofera o modalitate uniforma de descoperire si interactioanre.
Conceptul de baza al SOA este aceala de interconectare slaba, realizat 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 care respecta o schema
predefinita, dar extensibila, prin intermediul carora se trimite 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 urmatorele 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 servicii 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 coordonate si asambalte astfel
in cat s formeza un nou serviciu, numit un serviciu compus.
- Autonomia Serviciului un serviciu are control total asupra logicii pe care o
incapsuleaza
- Descoperirea Serviciilor serviciile sunt concepute astfel incat s isi descrie
functionalitatea catre exterior, astfel incat s poata fi gasite si folosite prin
intermediul unor mecanisme de descoperire.
Avand bazele puse pentru conceptul de SOA, in cele ce urmeaza se va incerca
definirea Serviciilor Web pe baza acestor concepte. Serviciile Web nu sunt altceva dect o
modalitate prin care o arhitectura SOA este realizate, folosind un anumit set de protocoale si
restrictii. In cazul concret al Serviciilor Web, urmatoarele doua restrictii sunt impuse:
- Interfetele serviciilor trebuie s fie construite peste protocoale din Internet, precum
HTTP, FTP sau SMTP.
- Exceptand atasamentele binare alea unor mesaje, toata comunicarea intre servicii
trebuie s fie fcut 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, gazduira, 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. Clasa de Servicii Web
de tip SOAP aduce urmatoarele constrangeri fata de cele mentionate 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 markup 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 dect s defineasca un format pentru mesaje care pot fi
trimise intre servicii web deasupra unui numar de protocoale internet. Cu alte cuvinte, SOAP
se comporta ca un plic care muta continut dintr-un punct in altul.
Pentru exemplificare, mai jos este un mesaj SOAP:
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<obtineDetaliiCursant xmlns="http://www.example.com/WebService">
<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 SOAP (de acum incolo
numit simplu Servicii Web) si cu adoptia lor pe piata, s-a facut 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 consecinta o suita de standarde
numite colectiv WS-* care trateaza aceste probleme. Telul acestor specificatii este acela de
a oferi sabloane pentru functionalitati avansate ale Serviciilor Web, totodata pastrand
simplitatea nativa a Serviciilor Web. Cea mai importanta trasatura a specificatiilor WS-* este
posibilitatea lor de a fi compuse. Compunearea protocoalelor asociate acestor specificatii
permite o dezvoltare incrementala a Serviciilor Web, pe masura ce functionalitatea lor o cere
(securitate, incredere, atasamente, tranzactii, descoperire, etc.). Individual fiecare
specificatie rezolva o problema izolta, dar ca un compus, ele rezolva probleme de
functionalitate ridicata adesea intalnite in aplicatii distribuite.
Modelul acesta poate fi exprimat schematic astfel:


In cele ce urmeaza se vor prezenta succint produsele din platforma Microsoft care
compun ecosistemul pentru construirea si mentenanta sistemlor distribuite implementate
folosing Servicii Web.
Constructia de Servicii Web se poate realiza
- folosind Microsoft Visual Studio 2005 in colaborare cu platforma .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 partea de proxy fiind
deasemenea generata automat pe partea de client. Suportul pentru descoperire este
deasemenea integrat prin suportarea protocolului UDDI.
- folosind Web Service Enhancements 3.0 [WSE 3.0] in colaborare cu VS2005 si .NET
2.0, se pot realiza Servicii Web care sunt in conformitate cu ultimele specificatii ale
WS-*. WSE 3.0 este oferit ca un pachet care se integreaza perfect 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 printre care si Windows
Communication Foundation, API care permite un model unificat de programare si
rulare a Serviciilor Web folosind limbaje managed, precum C#. WCF aduce suport
integral pentru toate standardele recunoscute cat si cele mai populare 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-SecureConversation
o pentru incredere: WS-ReliableMessaging
pentru tranzactii: WS-Coordination si WS-AtomicTransactions

Protocoale de reea 57
2. Protocoale de reea
2.1. Modelul de referin TCP/IP
Pana n anii 60, comunicarea ntre computere se realiza greoi prin intermediul liniilor
telefonice. n 1962 Paul Baran i Donald Davies propun independent ideea unui sistem
de comunicare ntre reele bazat pe comutarea de pachete packet switching. Aceast
arhitectura a fost implementat de ARPANET, o reea de calculatoare sponsorizat de DoD
(Department of Defence). Arhitectura a devenit cuoscut mai trziu sub denumirea de
modelul de referin TCP/IP, dup numele celor dou protocoale fundamentale utilizate.
Protocolul TCP (Transfer Control Protocol) se refera la modalitatea 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 pori de interconectare ar
putea fi distruse la un moment dat, un obiectiv major a fost ca reeaua s poat supravieui
pierderii echipamentelor din subreea, fr a ntrerupe conversaiile existente. Cu alte
cuvinte, DoD dorea ca, atta timp ct funcionau maina surs i maina destinaie,
conexiunile s rmn intacte, chiar dac o parte din maini sau din liniile de transmisie erau
brusc scoase din funciune. Mai mult, era nevoie de o arhitectur flexibil, deoarece se
aveau n vedere aplicaii cu cerine divergente, mergnd de la transferul de fiiere pn la
transmiterea vorbirii n timp real.
Toate aceste cerine au condus la alegerea unei reele cu comutare de pachete
bazat pe un nivel inter-reea fr conexiuni. Acest nivel, numit nivelul internet (IP), este
axul pe care se centreaz ntreaga arhitectur. Rolul su este de a permite gazdelor s
emit pachete n orice reea i face ca pachetele s circule independent pn la destinaie.
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 (acele 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 numr ntre 0 i 255. Spre exemplu, la
momentul redactarii acestui document, www.microsoft.com are ip-ul 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 numete i localhost. n anii `80 au fost conectate la Arpanet un
numr foarte mare de reele. Aceast situaie a determinat, n 1984, crearea sistemului DNS
(Domain Name System), prin intermediul cruia calculatoarele erau organizate n domenii,
punndu-se n coresponden adresele IP cu numele gazdelor.
Nivelul de transport sau TCP ataeaz pachetelor trimise un numr de port al
serviciului destinatar i direcioneaz pachetele care ajung, ctre o anumit aplicaie. Fiecare
serviciu comunic pe un anumit port. Porturile sunt numere ntregi care permit unui computer
s fac diferena ntre comunicaiile 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 aplicatiile care deservesc diferite servicii
pe un sistem ruleaza pe porturi diferite, putem avea servicii care ruleaza concomitent pe
acelasi calculator. Astfel, pe un sistem (server) pot rula concomitent aplicatii server si pentru
protocolul HTTP cat si pentru protocolul FTP. Un server poate deservi 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 mai comune porturi sunt: FTP :
20/21, Telnet: 23, HTTP: 80, Microsoft SQL Server:1433.
Printre protocoalele de nivel aplicatie, enumeram cateva din cele mai cunoscute:
HTTP, FTP, Telnet, SMTP, SSL, POP3, IMAP, SSH etc.
HTTP (Hyper Text Transfer Protocol) este un protocol client - server n care clienii
(browserele web) trimit o cerere unui server web. Dup ce serverul returneaz elementele
cerute (imagini, text etc.) conexiunea dintre client i server este ntrerupt. Acest lucru
nseamn c dup ce elementele cerute sunt descarcate pe calculatorul utilizatorului, iar
browserul descoper ca are nevoie de o alta resursa de pe server, se realizeaz o nou
cerere ctre acesta. Acest lucru nseamn c HTTP nu este orientate pe conexiune
(connection-oriented).
FTP (File Transfer Protocol) faciliteaz transferul de fiiere ntre dou calculatoare din
internet.
SMTP (Simple Mail Transfer Protocol) este un protocol folosit pentru schimbul de
mesaje de pot electronic.
Telnet este un protocol care permite unui utilizator s se conecteze de la un calculator
la altul.
SSL (Secure Socket Layer) este un protocol folosit pentru transmiterea de date text
criptate in internet.
Modelul TCP/IP este nrudit cu modelul de referin OSI (Open Systems
Interconnection). Modelul OSI este format din 7 straturi asigurnd astfel mai mult
flexibilitate. Acest model nu este folosit nsa n practic, rmnnd mai mult un model
teoretic. In figura de mai jos se poate vedea sitva de comunicare propusa de modelul
ISO/OSI cu cele 7 nivele ale sale. Nivelul cel mai de jos reprezinta 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 date, 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 Internetului, World-Wide
Web-ul mai pe scurt Web sau spaiul WWW, a fost instituit la CERN (Centre Europen
pour la Recherche Nuclaire Centrul European de Cercetri Nucleare de la Geneva) n
anul 1989. Web ul a aprut din necesitatea de a permite cercettorilor rspndii n lume
s colaboreze utiliznd colecii de rapoarte, planuri, desene, fotografii i alte tipuri de
documente aflate ntr-o continu dezvoltare.
Comunicaia dintre clientul web (browserul) i serverul web are loc n felul urmtor:
procesul server Web (spre exemplu Microsoft IIS Internet Information Services) ascult
portul TCP 80 al mainii gazde pentru a rspunde eventualelor cereri de conexiune venite de
la clieni. Dup stabilirea conexiunii TCP, clientul care a iniiat conexiunea trimite o cerere
(de exemplu un document HTML), la care serverul trimite un rspuns (documentul cerut sau
un mesaj de eroare). Dup trimiterea rspunsului conexiunea dintre client i server se
ncheie. Cererile clientului i rspunsurile serverului Web sunt descrise de protocolul HTTP
(Hyper Text Transfer Protocol).
Etapele care se parcurg ntre cerere i rspuns sunt:
1. Browserul determina URL ul cerut de utilizator.
2. Browserul ntreab serverul local DNS adresa IP a mainii pe care se afl pagina
cu URL-ul selectat.
3. Serverul DNS comunic browserului adresa IP cerut.
4. Browserul stabilete o conexiune TCP cu portul 80 al serverului cu IP ul obinut
anterior.
5. Utiliznd conexiunea TCP, browserul trimite o comand GET.
6. Serverul web rspunde trimind un fiier HTML.
7. Serverul Web nchide conexiunea TCP.
8. Browserul afieaz textul din fiierul HTML trimis.
9. Browserul cere i afieaz 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 rspuns 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; domain=.live.com; expires=Mon,
04-Oct-2021 19:00:00 GMT; path=/
Set-Cookie: frm=true; domain=.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 dispoziie de protocolul HTTP sunt:
HEAD clientul cere numai antetul paginii
GET - clientul cere serverului s trimit pagina specificat
POST - trimite date pentru a fi procesate pe server
PUT inlocuiete coninutul paginii specificate cu datele trimise de client
DELETE solicit tergerea paginii specificate
TRACE permite clientului s vad cum sunt prelucrate mesajele
OPTIONS returneaz metodele HTTP suportate de server
CONNECT - convertete conexiunea de tip cerere ntr-un tunel TCP/IP , de
obicei pentru a facilita comunicaii securizate prin SSL (HTTPS).

Formularele HTML sunt folosite pentru ca utilizatorii s introduc date n cmpurile
acestora i s le transmit serverului Web (utiliznd browserul, o conexiune TCP i
protocolul HTTP).
Cele mai rspndite 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 poate folosi metoda
GET sau metoda POST. Metoda implicit este GET.
Dac se utilizeaz GET, datele transmise serverului pot fi vizualizate n bara de
adrese a browserului, ele urmnd dup URL-ul fiierului ce conine scriptul care le va
prelucra. Datele introduse de utilizator vor fi sub forma de perechi nume=valoare. Caracterul
? semnific faptul c se transmit date ctre server, iar perechile nume=valoare pot fi
separate prin caracterul &. De exemplu pentru a cauta informaii 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 ctre server s se fac n flux,
putndu-se transmite cantiti mari de date. De asemenea, datele trimise nu mai sunt afiate
n bara de adrese a browserului, lucru util cnd se transmit informaii confideniale.
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-uri executate
pe serverul web. Acestea pot fi scrise in orice limbaj de programare (interpretat sau compilat)
cu respectarea urmatoarelor restrictii: programul scrie datele la iesirea standard si genereaza
antete care permit serverului Web s interpreteze corect iesirea scriptului, conform
specificatiilor HTTP.
PHP (iniial 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 ASP 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 cadrul 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 sunt capabile s construiasca
controale reutilizabile care s incapsuleze functionalitati complexe pentru interactiunea cu
utilizatorul
Perl (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 specificaia Java 2 Entreprise Edition (J2EE).
JSP utilizeaz sintaxa XML i o serie de clase i funcii 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 browserului de pe client. Programarea
la nivel de client se realizeaz n special prin JavaScript.

3. Programarea client - side
Unul din primele elemente fundamentale ale WWW ( World Wide Web ) este HTML
(Hypertext Markup Language), care descrie formatul primar in care 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 Consortium (W3C), care este
afiliat la Internet Engineering Task Force (IETF). W3C a enuntat cateva versiuni ale
specificatiei HTML, printre care si HTML 2.0, HTML 3.0,HTML 3.2, HTML 4.0 si, cel mai
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 , aceste 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 textului, 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 celula 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>c11</td>
</tr>
<tr>
<td>c21</td>
<td>c22</td>
</tr>
<tr>
<td>c31</td>
<td>c32</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 pixeli 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 absenta chenarului. Cand atributul
border are o valoare nenula chenarul unui tabel are un aspect tridimensional.

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

Pentru a alinia un tabel ntr-o pagina Web se utilizeaza atributul align al etichetei
<table>, cu urmatoarele valori posibile: " left " ( valoarea prestabilita ), " center " si "right ".
Alinierea este importanta pentru textul ce inconjoara tabelul. Astfel :
daca tabelul este aliniat stanga ( <table align="left"> ), atunci textul care
urmeaza dupa punctul de inserare al tabelului va fi dispus in partea dreapta a
tabelului.
daca tabelul este aliniat dreapta ( <table align="right"> ), atunci textul care
urmeaza dupa punctul de inserare al tabelului va fi dispus in partea 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 toata 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 eticheta <tr> sau celule de date prin
eticheta <td>. Valorile pe care le poate primi bgcolor sunt cele 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>
</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>
</body>
</html>

Culoarea textului din fiecare celula se pote stabili cu ajutorul expresiei:
<font color="valoare">...</font>.
Distanta dintre doua celule vecine se defineste cu ajutorul atributului cellspacing al
etichetei <table>.Valorile acestui atribut pot fi numere intregi pozitive, inclusiv 0, si reprezinta
distanta in pixeli dintre doua celule vecine. Valorea prestabilita 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 atribut pot fi numere intregi
pozitive, si reprezinta distanta in pixeli dintre celule si continutul ei. Valorea prestabilita a
atributului cellpadding este 1.
Dimensiunile unui tabel - latimea si inaltimea - pot fi stabilite exact prin intermediul a
doua atribute, width si height, ale etichetei <table>.Valorile acestor atribute pot fi:
numere intregi pozitive reprezentand latimea respectiv inaltimea in pixeli a
tabelului;
numere intregi intre 1 si 100, urmate de semnul %, reprezentand fractiunea
din latimea si inaltimea totala a paginii.

<html>
<head>
</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. Aceste celule sunt
introduse de eticheta <th> ( de la " tabel header " = cap de tabel ) 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 aldine si centrat.
Alinierea pe orizontala a continutului unei celule se face cu ajutorul 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 ajutorul 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 defini tuturor elementelor
celulelor unui rand, cat si etichetelor <td> si <th> pentru a stabili alinierea textului ntr-o
singura celula.
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 celule vecine.

Astfel:
extinderea unei celule peste celulele din dreapta ei se face cu ajutorul
atributului colspan, a carui valoare determina numarul de celule care se
unifica.
extinderea unei celule peste celulele dedesubt se face cu ajutorul atributului
rowspan, a carui valoare determina numarul de celule care se unifica.
Sunt posibile extinderi simultane ale unei celule pe orizontala si pe verticala. In acest
caz , in etichetele <td> si <th> vor fi prezente ambele atribute 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 ;
dupa <td> se pune <br>.
Caracterul ( no breakable space ) este de fapt caracterul 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 browserului subferestre in
care s fie incarcate documente HTML diferite.Ferestrele sunt definite ntr-un fisier HTML
special , in care blocul <body>...</body> este inlocuit de blocul <frameset>...</frameset>. In
interiorul acestui bloc, fiecare cadru este introdus prin eticheta <frame>.
Un atribut obligatoriu al etichetei <frame> este src, care primeste ca valoare adresa
URL a documentului HTML care va fi incarcat in acel frame. Definirea cadrelor se face prin
impartirea ferstrelor (si a subferestrelor) in linii si coloane:
impartirea unei ferstre ntr-un numar de subferestre de tip coloana se face cu
ajutorul atributului cols al etichetei <frameset> ce descrie acea fereastra;
impartirae unei ferestre ntr-un numar de subferestre de tip linie se face cu
ajutorul atributului rows al etichetei <frameset> ce descrie acea fereastra;
valoare atributelor cols si rows este o lista de elmente separate 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 terminat cu %);
n* care inseamna n parti din spatiul ramas;
Exemplu 1: cols=200,*,50%,* inseamna o impartire in 4 subferestre, 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 subferestre , 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, 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 * , atunci 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 subfereste (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 mixte.Pentru a o crea se
procedeaza din aproape in aproape. Mai intai, pagina este impartita in doua subferestre de
tip coloana, dupa care a doua subfereastra este impartita in doua subferestre de tip linie.

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

Pentru a stabili culoarea chenarului unui cadru se utilizeaza atributul bordercolor.
Acest atribut primeste ca valoare un nume de culoare sau o culoare definita in conformitate
cu modelul de culoare RGB.Atributul bordercolor poate fi atasat atat etichetei <frameset>
pentru a stabili culoarea tuturor chenarelor cadrelor incluse,cat si etichetei <frame> pentru a
stabili culoarea chenarului pentru un cadru individual.
Atributul border al etichetei <frameset> permite configurarea latimii chenarelor tuturor
cadrelor la un numar dorit de pixeli. Valoarea prestabilita a atributului 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="p2.html" bordercolor="blue"> <frame src="p3.html">
</frameset>
</html>
Pentru a obtine cadre fara chenar se utilizeaza border="0". In mod prestabilit,
chenarul unui cadru este afisat si are aspect tridimensional. Afisarea chenarului unui cadru
se poate dezactivata daca se utilizeaza atributul frameborder cu valoare "no". Acest atribut
poate fi atasat atat etichetei <frameset> (dezactivarea fiind valabila 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>
<frameset cols="20%,*" border="0">
</frameset>
</html>

Atributul scrolling al etichetei <frame> este utilizat pentru a adauga unui cadru o bara
de derulare care permite navigarea in interiorul documentului afisat 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 necesar

<html>
<frameset cols="*,*,*">
<frame src="p.html" scrolling="yes" noresize>
<frame src="p.html" scrolling="no" noresize>
<frame src="p.html" scrolling="auto" noresize>
</frameset>
</html>

Atributul noresize al etichetei <frame> (fara nici o valoare suplimentara) daca este
prezent, inhiba posibilitatea prestabilita a utilizatorului de a redimensiona cadrul cu ajutorul
mouse-ului.
Un cadru intern este specificat prin intermediul blocului <iframe>...</iframe>. Un
cadru intern se insereaza ntr-o pagina Web in mod asemanator cu o imagine sau in modul
in care se specifica marcajul <frame>, asa cum rezulta din urmatorul exemplu: <iframe
src="iframes_ex.html" height=40% width=50%> </iframe>
In acest caz fereastra de cadru intern care are 40%din inaltimea si 50% din latimea
paginii curente.
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 (acelasi cadru). Acest
comportament se poate schimba in doua moduri:
prin plasarea in blocul <head>...</head> a unui element <base> care
precizeaza,prin atributul target numele ferestrei (cadrului) in care se vor
incarca toate paginile noi referite de legaturile din pagina curenta conform
sintaxei: <base target="nume_ferastra/frame_de_baza">
prin plasarea in eticheta <a> a atributului target, care precizeaza numele
ferestrei (cadrului) in care se va incarca pagina nou referita de legatura,
conform sintaxei: <a href="legatura" target="nume_fereastra/frame">...</a>
Daca este prezent atat un atribut target in <base> cat si un atribut target in <a>,
atunci cele precizate de atributul target din <a> sunt prioritare.
Numele unui cadru este stabilit prin atributul name al etichetei <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>
<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 curent);
"_top" (incarcarea noii pagini are loc in fereastra browserului ce contine cadrul
curent);
3.1.3. Formulare

Un formular este un ansamblu de zone active alcatuit din butoane, casete de
selectie, campuri de editare etc. Formularele asigura construirea unor pagini Web care
permit utilizatorilor s introduca informatii si s le transmita serverului. Formularele pot varia
de la o simpla caseta de text , pentru introducerea unui sir de caractere pe post de cheie de
cautare, pana la o structura complexa, cu multiple sectiuni, care ofera facilitati puternice de
transmisie a datelor.
Un formular este definit ntr-un bloc delimitat de etichetele corespondente
<form> si </form>.
Exista doua atribute importante ale elementului <form>.
1. Atributul action precizeaza ce se va intampla cu datele formularului odata ce
acestea ajung la destinatie. De regula , valoarea atributului action 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 shell. 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 cantitati 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 atribute 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 valoarea 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="Last" 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 care le poate
primi un camp de editare; caracterele tastate peste numarul maxim sunt
ignorate.
Daca se utilizeaza eticheta <input> avand atributul type configurat la valoarea
"password" , atunci in formular se introduce un element asemanator 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 camp de editare nu
afiseaza caracterele in clar, ci numai caractere *, care ascund de privirile altui
utilizator aflat in apropiere valoarea introdusa ntr-un asemenea camp. La expedierea
formularului insa, valoarea tastata ntr-un camp de tip "password" se transmite in
clar.

<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="prenume" value="Prenumele"><br>
Password:<input type="password" name="parola" ><br>
<input type="reset" value="sterge"> <input type="submit" value="trimite"> </form></body>
</html>

Butoanele radio permit alegerea , la un moment dat , a unei singure variante
din mai multe posibile. Butoanele radio se introduc prin eticheta <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 deselectarea unei
optiuni. Pentru inserarea unei casete de validare se utilizeaza eticheta <input> cu
atributul type configurat la valoarea "checkbox".
Fiecare caseta poate avea un nume definit prin atributul name.fiecare caseta poate
avea valoarea prestabilita "selectat" definita prin atributul checked.

<p>Please select every sport that you play.</p>
Soccer: <input type="checkbox" checked="yes" name="sports" value="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 intregul continut
al unui fisier pe post de valoare. Pentru aceasta se insereaza un element <input>
ntr-un formular , cu atributul type avand valoarea "file" (fisier). Atributele pentru un
element de tip caseta de fisiere:
atributul name permite atasarea unui nume
atributul value primeste ca valoare adresa URL a fisierului care va fi expediat o
data cu formularul. Aceasta valoare poate fi atribuita direct atributului value, se
poate fi tastata ntr-un camp de editare ce apare o data cu formularul sau poate fi
selectata prin intermediul unei casete de tip File Upload sau Choose 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 utilizatorului s aleaga unul sau mai multe elemente
dntr-o lista finita. Lista de selectie este inclusa in formular cu ajutorul etichetelor
corespondente <select>si </select>.
O lista de selectie poate avea urmatoarele atribute:
atributul name, care ataseaza listei un nume (utilizat in perechile "name=value"
expediat serverului);
atributul size, care precizeaza (prntr-un numar intreg pozitiv , 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 ajutorul 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 catre server va fi
expediat textul ce urmeaza dupa <option>;
atributul selected (fara alte valori) permite selectarea prestabilita 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 intocmai ca o lista de
selectie obisnuita. In plus, eticheta <select> are un atribut multiple (fara alte valori).
Cand formularul este expediat catre server pentru fiecare element selectat al listei
care este se insereaza cate o pereche "name=value" unde name este 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 editare multilinie pot fi incluse cu ajutorul etichetei
<textarea>. Eticheta are urmatoarele atribute:
atributul cols, care specifica numarul de caractere afisate ntr-o linie;
atributul rows, care specifica numarul de linii afisate simultan;
atributul name, care permite atasarea unui nume campului de editare multilinie;
atributul wrap, (de la "word wrap"=trecerea cuvintelor pe randul 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 produce 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 editorului ;
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 editorului ;
nu se include caracterul de sfarsit de linie in textul transmis serverului o data cu
formularul;

<textarea cols="20" rows="5" wrap="hard">
As you can see many times word wrapping is often the desired look 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 look 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 HTML 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 eticheta <input> avand atributul type
configurat la valoarea "button".Alte doua atribute ale elementului "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 definirea
documentelor ce contin informatii ntr-un mod structurat. Informatia 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 are alt rol fata de cel din
footer, care la randul lui e diferit de continutul dintr-un tabel al unei baze de date). Toate
documentele au o anumita structura. Aceste structuri se construiesc utilizand marcatori.
W3.org se ocupa de standardizarea XML-ului, si specificatiile complete 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 un header de nivel 1, iar tag-
ul <documentHTML> nu are nici un sens (nu are asociata nici o valoare 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 marcatori (markup language).
Cu alte cuvinte XML permite definirea de tag-uri precum si relatia dintre acestea. Deoarece
nu exista o multime de tag-uri predefinita, nu exista nici o semantica asociata cu acestea.
Definirea semantica documentelor XML este o sarcina a aplicatiilor 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 format XML;
XML ofera facilitati multiple si imbunatatite de prezentare (de exemplu folosind
browserele)
Structura unui document XML 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>
<book> este elementul rdcin (root), title, prod i chapter sunt frai (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 posibilitati de personalizare
a paginilor Web. Un stil reprezinta un mod de a scrie un bloc de 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 browser cum s arate
un document. Regulile de stil sunt formate dup cum urmeaz: selector { property:
value }
Declaraiile de stil multiple pentru un singur selector pot fi desprite de punct
i virgul:
selector { property1: value1; property2: value2 }
Ca exemplu, urmtorul segment de cod definete proprietile culoare (color)
i mrime-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 posibil selector CSS1. Selectorul este elementul
care este legatla un stil particular. De exemplu, selectorul n declaraia CSS: P { text-
indent: 3em }, este P.
Declaraiile CSS pot fi introduse ntr-o pagina HTML n 3 moduri: inline, intern
i extern.
1) Declaraia inline se realizez cu ajutorul tag-ului style. De exemplu:
<p style="background: blue; color: white;">A new background and font color
with inline CSS</p>
La modul general declaraia este de forma:
<htmltag style="cssproperty1: value; cssproperty2: value;"> </htmltag>
O eroare des ntlnit este folosirea n interiorul declaraiei de mai sus:
<p style="background: url("yellow_rock.gif");">Greit</p>
<p style="background: url(yellow_rock.gif);">Corect</p>

2) Declaraia 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>

3) Declaraia extern. Atunci cnd se folosete CSS este de preferat s se separe
codul HTML de cosdul CSS. De aceea, declaraiile CSS se pun de obicei ntr-un fiier
separat, cu extensia .css . Avantajele unei asemenea abordari sunt:
separarea coninutului paginii de design, crescnd lizibilitatea codului html
modificarea uoar a design-ului unui site prin modificarea ntr-un singur fiier
css dect in mai multe pagini html
reutilizarea uoar a codului css
Declaraia extern se realizeaz prin intermediul tag-ului <link></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 this page is gray
because we changed it with CSS! </p>
</body>
</html>

Fiierul test.css trebuie s se afle n acelai director cu pagina html.
n CSS se pot defini aa numitele clase. Un simplu selector poate avea diferite
clase, astfel permindu-i aceluiai element s aib diferite stiluri. Toate tagurile din
pagina HTML cu aceeai clas vor fi formatate identic.

p.html { color: #191970 }
p.css { color: #4b0082 }

Exemplul de mai sus a creat dou clase, css i html pentru folosirea cu tag-ul
P al HTML. Caracteristica CLASS (clas) este folosit n HTML pentru a indica clasa
unui element, ca de exemplu,
<P CLASS = html>Doar o clas este permis pentru un selector. </P>
<P CLASS = css> De exemplu, p.html.css este invalid.</P>
<P CLASS = html>Acest rnd are aceeai culoare cu primul. </P>

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

Selectorii ID sunt sunt desemnai cu scopul de a defini elemente n mod
individual i nu mai multe elemente o dat ca n cazul claselor. Un selector ID este
desemnat folosind indicatorul "#" care precede un nume. De exemplu, un selector ID
ar putea fi desemnat astfel:

#text3M { text-indent: 3em }
La acest selector se va face referin n HTML folosind caracteristica ID:
<P ID=text3M>Textul are n fa un spaiu de mrimea a trei litere `m`</P>

O proprietate este desemnat unui selector pentru a-i manipula stilul. Exemplele de
proprieti includ color, margin, i font.
Pentru a descrie formatrile repetate ntr-o foaie de stil, gruparea selectorilor i a
declaraiilor este permis. De exemplu, toate titlurile dintr-un document ar putea primi
declaraii identice prntr-o grupare:
H1, H2, H3, H4, H5, H6 {color: red; font-family: sans-serif }
Toi selectorii care sunt interpui n cadrul altor selectori vor moteni valorile
proprietilor selectorilor n cadrul crora sunt interpui, dac nu se specific altfel. De
exemplu, o culoare definit pentru BODY va fi aplicat i textului dintr-un paragraf.
Exist i cazuri n care selectorul coninut nu motenete valorile selectorului care l
conine, dar acestea ar trebui s se evidenieze n mod logic. De exemplu, proprietatea
margin-top nu este motenit; n mod intuitiv, un paragraf nu va avea aceeai margine de
sus cum o va avea tot documentul (prin selectorul body).
O list complet a selectorilor CSS putei gsi la
http://www.w3schools.com/css/default.asp

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/Remove Programs -> Add/Remove Windows Components.

4.2. Caracteristici ale ASP si ASP .NET
ASP (Active Server Pages) reprezint o tehnologie creat de Microsoft pentru a crea
pagini web dinamice, ce are la baz stocarea si execuia scripturilor pe serverul Web.
Serverele Web care suporta tehnologia ASP sunt n numr 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 execuie;
Securitate ridicat, datorit faptului c scriptul nu poate fi vizualizat n
browser;
Generarea dinamic a rspunsurilor ctre clienii WEB, etc.

Microsoft .NET este o platforma de dezvoltare software, care are menirea de a oferi
programatorilor un mediu in care sunt puse la dispozitie diverse servicii cum sunt:
managementul firelor de executie, managementul duratei de viata a obiectelor (Garbage
Collection), tratarea exceptiilor, etc; si care determina o viteza mult mai mare a dezvoltarii
aplicatiilor dect direct pe platforma Win32, adica direct pe sistemul de operare Windows.
Inovaia adus de Microsoft, const n dezvoltarea unei platforme comune pentru mai
multe limbaje de programare, platform care permite dezvoltarea unei aplicaii n orice limbaj
doreste programatorul. Acest lucru este posibil prin dezvoltarea unui interpretor Comon
Language Runtime care transform codul de program dintr-un limbaj oarecare, compatibil
cu platforma .NET, n limbajul Microsoft Intermediate Language. Codul rezultat n limbajul
Microsoft Intermediate Language, se poate apoi compila pentru orice sistem de operare care
are instalat .NET Framework. Paginile web dinamice create cu ajutorul ASP pot ngloba mai
multe tipuri de tehnologii Web existente. De asemenea, scripturile 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 aplicaiilor Windows cu cele de WEB;
Programarea server side cu ASP.NET 77
Faciliteaz interoperabilitatea ntre aplicaii, indiferent de platforma pentru
care sunt create;
Asigur serializarea/deserializarea obiectelor;
Asigur un mediu stabil de programare obiectual;
Instalare simplificat, fr conflicte ntre versiuni;
Execuia securizat a codurilor;
Utilizeaz standardele existente pentru comunicare;
nlocuirea mediului script cu cel compilat, n cazul aplicaiilor ASP
Codul de program al unei aplicaii, scris ntr-un anumit limbaj de programare,
poate fi integrat fr probleme n alt aplicaie, scris n alt limbaj de
programare, etc.;

Printre limbajele care suport .NET, n primul rnd trebuie amintite cele dezvoltate de
Microsoft VB .NET, C# .NET, Visual C++ .NET, ct si limbaje dezvoltate de alte firme:
Borland C#, Cobol, Eiffel, Perl, Phython, Smalltalk, Pascal, Fortran, etc.
Limbajele de programare dezvoltate de Microsoft, desi au toate la baz aceeasi
platform, pot fi clasificate n funcie de gradul de complexitate:
VB .NET, este cel mai accesibil, fiind o evoluie 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 evoluie a mediului VC++ 6.0.
ASP .NET reprezint o evoluie a ASP bazat pe o nou tehnologie dezvoltat de
Microsoft, si anume platforma: .NET Framework. Tehnologia ASP .NET, aduce mbuntiri
semnificative fa de ASP, cele mai evidente fiind urmtoarele:
Execuia este mai rapid;
Este independent de programul de navigare pe Internet;
Codul aplicaiei este compilat si executat de server; acesta, n cazul ASP,
este interpretat pe msura parcurgerii scripturilor;
Utilizeaz noiunea de code behind, adic separ partea de prezentare de
partea de execuie a unei aplicaii WEB;
Favorizeaz reutilizarea codului, ceea ce n cazul ASP simplu, era o
problem, singura reutilizare care se fcea n ASP, fiind aceea de copiere a
codului;
Serializarea/deserializarea cu usurin a obiectelor;
Asigur interoperabilitatea ntre aplicaii WEB, ntre aplicaii WEB si alte
categorii de aplicaii;
Securitate crescut;
Datorit platformei .NET, pot fi nglobate cu usurin n aplicaiile WEB toate
componentele care erau pn acum caracteristice doar mediului Windows.
Microsoft ASP .NET este urmtoarea generaie a tehnologiei de dezvoltare a
aplicaiilor Web. Ea preia tot ce este mai bun de la Active Server Pages (ASP) la fel ca si
serviciile bogate si facilitile oferite de Common Language Runtime (CLR) si multe alte
faciliti noi. Rezultatul este o nou modalitate de dezvoltare web rapid, scalabil si robust
care permite o mare flexibilitate cu foarte puine linii de cod scrise. Web Forms reprezint
partea central pe care se bazeaz ASP .NET. Acestea reprezint elementele de interfa cu
utilizatorul care dau aplicaiilor web aspectul si comportamentul dorit. Formularele Web sunt
similare formularelor Windows prin faptul c ofer proprieti, metode si evenimente
controalelor plasate pe ele. Totusi, aceste elemente de interfa sunt afisate prin intermediul
limbajului HTML, iar n cazul utilizrii Microsoft Visual Studio .NET poate fi folosit interfaa
familiar de tip drag-and-drop pentru crearea aspectului formularelor Web. Formularele Web
sunt constituite din dou componente: partea vizual (fisierul .ASPX) si codul din spatele
formularului, care este stocat n fisiere separate.
4.3. Crearea de aplicaii WEB folosind ASP.NET
Pentru a crea aplicaii web cu ASP.NET avem nevoie de urmtoarele instrumente
software:
Microsoft Internet Information Services (IIS) este serverul de aplicatii web al
Microsoft. El este o componenta a Windows XP: Add/Remove Programs -> 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, unelte de debug si deployment.
Colectia de namespaces System.Web. Acestea sunt parte integranta a .NET
Framework si include clase predefinite care se ocupa de chestiuni specifice aplicatiilor web.
Controalele HTML si server sunt componente ale interfetei cu utilizatorul care sunt
folosite pentru a afisa respectiv colecta informatii catre / dinspre 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 Express Edition, care
instaleaza automat si .NET Framework si inregistreaza ASP.NET in 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 WebDeveloper 2005 Express
Edition: File -> New Web Site -> ASP.NET Web Site. Se alege la opiunea 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. Se poate
ajunge la acel fisier cu click dreapta pe Form si View Code. Acest fisier
are atasate automat cateva namespaces (folosind cuvantul cheie din
limbajul C# using), printre care se pot observa si cele din familia
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 informatii gen
constante care s poata fi regasite din codul executabil. Avantajele stocatii
unor astfel de constante in web.config sunt: modificarile in acest fiser nu
atrag dupa sine necesitatea de recompilare a aplicatiei, respectiv
informatiile sunt ntr-un singur loc si pot fi modificate cu usurinta. (n
fereastra soluion explorer, click dreapta pe website1, add existing item i
apoi web.config)
In general, se recomanda ca designul aplicatiilor (din punct de vedere al ingineriei
software si nu vizual) s respecte anumite criterii. Astfel, daca 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 specifice aplicatiei.
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 cele 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. Toolbox-ul este alcatuit din
tab-urile Standard, Data, Validation, Navigation, Login, WebParts, 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 formatarea controalelor cu stiluri
predefinite, atasarea de date, setarea modului de vizualizare etc.
Observati ca atunci cand introduceti controale ntr-un Form web, in codul "din spatele
acestuia", adica in fisierul .cs asociat, se produc niste modificari: se creaza un nou obiect, in
functie de ce anume ati adaugat, ca instanta al uneia dintre clasele 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 biblioteca, 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, butoanele au
Click, textbox-urile au TextChanged, etc.)
In momentul in care doriti s tratati un eveniment, s spunem apasarea unui buton de
catre utilizator, trebuie s asociati un handler evenimentului predefinit Click al butonului
respectiv. Un handler nu este altceva dect o functie, iar asocierea respectiva se poate face
foarte usor din Visual Studio.
Pentru cazul anterior, este suficient dublu-click pe buton, pentru ca s se creeze
automat o metoda de tipul
protected void ButtonX_Click(object sender, EventArgs e){}
4.3.3. Formulare 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 controlat, 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 .cs (pentru limbajul Visual C#) sau
.vb (pentru Visual Basic.NET). Fisierele .aspx mai sunt referite ca pagini ASP.NET. Aceasta
tehnica de separare a codului de partea de prezentare este numita"code-behind
programming"
Formularele Web si ASP .NET au fost create pentru a depsi cteva dintre limitrile
ASP. Principalele faciliti noi sunt redate n continuare:
Separarea interfeei HTML de logica aplicaiei
Un set bogat de controale pentru server ce detecteaz tipul browserului si
genereaz limbaj HTML corespunztor acestuia
Mai puin cod de scris din cauza modului n care sunt construite noile
controale server
Model de programare bazat pe evenimente
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 ctre teri care s aduc noi funcionaliti.
Logica aplicatiei reprezinta in fapt o clasa care extinde functionalitatea 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, atunci aceasta este apelata la
fiecare acces al unui formular Web), proprietati (de exemplu, prin proprietatea IsPostBack
putem afla daca o pagina Web este la primul acces sau la accesari 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 privita ca un program
executabil pentru care iesirea standard o reprezinta browserul sau dispozitivul client. In acest
model, pagina trece prntr-o serie de stagii de procesare: initializare, procesare si eliberare.
In ordinea aparitiei, acestea sunt:
Init, eveniment care initializeaza pagina si in care proprietatile controalelor
sunt actualizate. Aici este corect s initializam controale care se adauga dinamic la pagina
sau variabile necesare inainte de initializarea paginii;
Load poate fi numit locul in care utilizatorul isi initializeaza 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 tratate ntr-o anumita ordine pe
server, iar tratarea lor are loc dupa aparitia unui eveniment Click care trimite formularul la
server (a unui submit);
PreRender, eveniment care poate fi folosit pentru a face ultimile 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 pagina s fie
eliberata. Evenimentul este util de folosit atunci cand dorim s efectuam ultimele operatii de
eliberare a resurselor: inchiderea fisierelor, a conexiunilor la 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 capabilitatile
elementelor HTML pe care le afiseaza;
Web Controls, aduc facilitati superioare controalelor HTML incluzand
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 ajutorul Frontpage
sau al oricrui 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="text" id=txtFirstName
size=25>
Orice element poate fi ns marcat s ruleze ca si un control HTML atunci cnd
formularul este procesat de server prin adugarea textului "runat=server" n interiorul tagului.
<input type="text" id=txtFirstName size=25 runat=server>
n cazul folosirii Visual Studio .NET, adugarea acestui text ce permite procesarea
controlului de ctre server se poate face foarte simplu dnd clic dreapta pe elemental HTML
n Design View si selectnd Run as Server Control din meniul contextual.
Controalele HTML permit de asemenea tratarea evenimentelor asociate cu tagul
HTML (clic pe un buton, de exemplu) si manipularea n mod programatic 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 Formularul Web, mai puin textul
runat=server, ceea ce ofer un control foarte precis a ceea ce va fi trimis ctre 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) de afisare;
posibilitatea de a controla generarea evenimentelor pe server;
posibilitatea de a trimite evenimente unui container din interiorul 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 mostenesc, 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 valoarea, 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 executa Page_Load) la
fiecare raspuns al serverului pentru un eveniment (cum ar fi apasarea 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: Query 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 dorim s le pastram pe durata
intregii executii a aplicatiei de catre utilizatorul curent. Astfel 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 variabilele sunt de tip
object, iar atribuirea se face unui obiect de tip Feedback (o clasa 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 lucru, diferena fiind ca
primul este un control care rezida in .aspx, iar metoda se apeleaza 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 parametrul 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 EnableViewStateMac din directiva Page
(fisierul .aspx) pe valoarea false. Deoarece in mod normal informatia 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 general, se poate face
acest lucru atat din IIS Management Console (click dreapta pe un director virtual din IIS,
Properties, Directory Security, Edit) unde se pot alege mai multe tipuri de autentificare
{Anonymous, Windows Integrated, Digest for Windows domain servers, 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 implicit 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 Student.aspx, atunci
IUSR_<numele_masinii> trebuie s aib dreptul de a citi fisierul de pe hard-disk
corespunzator, s spunem c:\Inetpub\wwwroot\library\student.aspx.
Pentru o aplicatie securizata, avem mai multe posibilitati de autentificare, cele mai
des intalnite fiind sintetizate in tabelul de pe slide. Implementarea politicii de securitate se
poate face atat din IIS cat si din aplicatia ASP.NET.

Tipul
aplicatiei
Modul
de autentificare
Descriere
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.

4.3.7.1.1 Windows Authentication
n acest mod de autentificare, aplicaia ASP .NET are ncorporate procedurile de
autentificare, dar se bazeaz pe sistemul de operare Windows pentru autentificarea
utilizatorului.
1. Utilizatorul solicit o pagin securizat de la aplicaia Web.
2. Cererea ajunge la Serverul Web IIS care compar datele de autentificare ale
utilizatorului cu cele ale aplicaiei (sau ale domeniului)
3. Dac acestea dou nu corespund, IIS refuz cererea utilizatorului.
4. Calculatorul clientului genereaz o fereastr de autentificare,
5. Clientul introduce datele de autentificare, dup care retrimite cererea ctre IIS
6. IIS verific datele de autentificare, si n cazul n care sunt corecte, direcioneaz
cererea ctre aplicaia Web.
7. Pagina securizat este returnat utilizatorului.
4.3.7.1.2 Forms-Based Authentication
Atunci cnd se utilizeaz autentificarea bazat pe formulare, IIS nu realizeaz
autentificarea, deci este necesar ca n setrile acestuia s fie permis accesul anonim.
1. n momentul n care un utilizator solicit o pagin securizat, IIS autentific clientul
ca fiind un utilizator anonim, dup care trimite cererea ctre ASP.NET.
2. Acesta verific pe calculatorul clientului prezena unui anumit cookie1
3. Dac cookie-ul nu este prezent sau este invalid, ASP .NET refuz cererea
clientului si returneaz o pagin de autentificare (Login.aspx).
4. Clientul completeaz informaiile cerute n pagina de autentificare si apoi trimite
informaiile
5. Din nou, IIS autentific clientul ca fiind un utilizator anonim si trimite cererea ctre
ASP .NET
6. ASP .NET autentific clientul pe baza informaiilor furnizate. De asemenea
genereaz si un cookie.
Cookie reprezint un mic fisier text ce pstreaz diverse informaii despre utilizatorul
respectiv, informaii folosite la urmtoarea vizit a s pe site-ul respectiv, la autentificare, sau
n diverse alte scopuri.
7. Pagina securizat cerut si noul cookie sunt returnate clientului. Atta timp ct
acest cookie rmne valid, clientul poate solicita si vizualiza orice pagin securizat ce
utilizeaz aceleasi informaii de autentificare.
4.3.7.1.3 Passport Authentication
La utilizarea Serviciului Web Microsoft Passport, nici IIS nici aplicaia Web nu se
ocup de autentificarea clientului. Atunci cnd utilizatorul cere o pagin securizat, cererea
este trimis mai nti serverului IIS.
1. IIS autentific clientul ca utilizator anonim si trimite cererea ctre ASP .NET.
2. Acesta verific prezena unui anumit cookie pe calculatorul clientului.
3. Dac cookie-ul nu exist, cererea este refuzat si clientul este direcionat ctre
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 corespunztoare si le trimite napoi ctre
Passport.com.
6. Dac informaiile introduse se potrivesc cu cele din baza de date Passport.com, clientul
este autentificat si primeste un cookie corespunztor informaiilor introduse.

4.4. ADO.NET
ADO.NET este componenta din .NET Framework care se ocupa cu accesul la baze
de date ; este standardizata in sensul ca se pot folosi aceleasi obiecte pentru accesarea
diferitelor tipuri de baze de date : Access, MS SQL Server, Oracle, etc. Sunt necesare la
referinte doua namespaces : System.Data si System.Data.SqlClient 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 date. Aceasta conexiune poate fi
accesata direct de un obiect Command sau de un obiect DataAdapter. Obiectul Command
executa o comanda asupra bazei de date. Daca se returneaza valori multiple, se utilizeaza
un obiect DataReader care va contine datele returnate. Aceste date pot fi procesate direct de
de aplicatie. Alternativ, se poate utiliza un DataAdapter pentru a popula un obiect DataSet.
Modificarile asupra bazei de date se pot efectua prin intermediul 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 deschiderii unui canal de
comunicatie cu baza de date in cadrul proprietatii ConnectionString. Sunt incorporate, de
asemenea, metode pentru facilitarea tranzactiiilor.
Command este reprezentat de doua clase: SqlCommand si OleDbCommand Utilizat
pentru a efectua apeluri de proceduri stocate sau de comenzi SQL asupra bazei de date sau
pentru a returna tabele.
Metode:
ExecuteNonQuery - executa comenzi care nu returneaza inregistrari -
INSERT, UPDATE, DELETE
ExecuteScalar - returneaza o singura valoare dntr-o interogare
ExecuteReader - returneaza o multime rezultat, sub forma unui obiect
DataReader
DataReader
contine un recordset bazat pe conexiune, forward-only, read-only
obiectele DataReader nu pot fi instantiate direct, sunt returnate 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 activa 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 apeleaza
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 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 biblioteca, unde se
poate dori afisarea tuturor cartilor dintr-un anumit domeniu, etc.

4.4.1. Obiectele ADO.Net
4.4.1.1.1 SqlConnection
Un obiect SqlConnection este la fel ca orice alt obiect 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=DatabaseServer;Initial
Catalog=Northwind;User ID=YourUserID;Password=YourPassword");
OleDbConnection oleDbConn = new
OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=MyDatabase.mdb");

Obiectul SqlConnection de mai sus este instantiat folosind un constructor care
primeste ca parametru un string. Acest argument este stringul de conectare.
Scopul instantierii unui obiect de tip SqlConnection este ca alte obiecte ADO.Net s
poata lucra cu baza de date. Alte obiecte, cum ar fi SqlDataAdapter si SqlCommand, au
constructori care primesc obiectul conexiune ca parametru. Atunci 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 actiune asupra bazei de
date. De exemplu se poate face o interogare, inserare, modificare sau stergere.
Atunci cand se realizeaz o interogare in baza de date, se obine un tabel rezultat
care trebuie s poata fi vizualizat. Pentru a obtine acest lucru folosind obiecte SqlCommand
este folosita metoda ExecuteReader care intoarce un obiect de tipul SqlDataReader.
Exemplul de mai jos arata modul de obtinere a unei instante SqlDataReader.
SqlCommand cmd = new SqlCommand ("SELECT CategoryName FROM Categories",
conn);
SqlDataReader rdr = cmd.ExecuteReader();
Pentru a insera valori ntr-o baza de date trebuie apelata functia ExecuteNonQuery
pe un obiect SqlCommand. Exemplul urmator arata modul de inserare ntr-o baza de date.

string insertString = @"INSERT INTO Categories (CategoryName, Description)
VALUES ('Miscellaneous', 'Whatever doesn''t fit elsewhere')";
SqlCommand cmd = new SqlCommand (insertString, conn);
cmd.ExecuteNonQuery();

Modificarea si stergerea datelor dntr-o baza de date se face la fel ca si inserarea,
dar ca punem primul parametru al constructorului SqlCommand pe valoarea
corespunzatoare.
Uneori avem nevoie dntr-o baza de date doar de o singura valoare, care poate fi
suma, media, etc. inregistrarilor dintr-un tabel. Apeland ExecuteReader si apoi calculand
acea valoare in program nu este cea mai eficienta metoda de a ajunge la rezultat. Cea mai
buna metoda este s lasam baa de date s faca ceea ce este necesar si s intoarca o
singura valoare. Acest lucru il face metoda ExecuteScalar:

SqlCommand cmd = new SqlCommand ("SELECT count(*) FROM Categories", conn);
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 informatie nu mai poate fi citita inca
o data. SqlDataReader citeste secvential date.
Datprita faptului ca citeste doar inainte (forward-only) permite 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 diferita de instantierea
normala - trebuie apelata metoda ExecuteDataReader. Daca pentru instantiere este folosit
operatorul new veti obtine un obiect cu care nu puteti face nimic 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 itera 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 stream.

4.4.1.1.4
4.4.1.1.5 Instalarea unei aplicaii 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-ului 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 (asta se face prin simpla
copiere), mergeti in IIS, click dreapta pe Default Web Site, New -> 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 putea 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 crearea directorului virtual in IIS.
Evident, trebuie neaparat s aveti grija de securizarea aplicatiei 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 primul rand, s ne imaginam o
aplicatie de E-Commerce care lucreaza cu un server de baze de date 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 diferit la fiecare client.
Cum facem deci s putem livra aplicatia clientilor, fara a recompila codul la fiecare ? Cum
facem conexiunea la baza de date pentru fiecare client ? Ei bine, 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 contine 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:

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;
}

5. Referinte

http://www.sei.cmu.edu/str/descriptions/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
activitilor didactice

MiniGhid Metodologic Informatic & TIC
91

Cuprins

I.Programa colar reper obligatoriu pentru un demers flexibil...93
II.Aplicarea programelor colare............................................................................94
III.Proiectarea demersului didactic........................................................................95
III.1. Lectura personalizat a programelor colare
III.2. Planificarea calendaristic
III.3. Proiectarea unei uniti de nvare
III.4. Proiectarea activitii de evaluare
III.4.1. Tipuri de itemi
III.4.2. Metode complementare de evaluare

IV. Proiectul unitii de nvare - Proiectul de lecie ?....................................107
V. Anexe 108
1. Planificri calendaristice i Proiecte de uniti de nvare

93

I.Programa colar reper obligatoriu pentru un demers flexibil

Programa colar este parte a Curriculumului national. Termenul de curriculum deriv din limba latin
unde, printre altele nseamna drum ctre.
Programa colar descrie oferta educaional a unei anumite discipline pentru un parcurs colar determinat
Filosofia contemporan a educaiei a evideniat diferena dintre o educaie bazat pe curriculum, adic
avnd ca element central la toate etajele sale activiatea de proiectare i programa analitic, care are n
centrul activitii didactice ideea de programare a traseului elevului ctre un el cunoscut i impus doar de
ctre aduli.
Conceptual, programele colare actuale, se difereniaz de ,,programele analitice" prin accentul pe care l
pun pe interiorizarea unui mod de gndire specific fiecrui domeniu transpus n coal prin intermediul unui
obiect de studiu, nu pe succesiunea coninuturilor i pe numrul de ore alocat lor.
Actualele programe colare subliniaz importana rolului reglator al achiziiilor elevilor n plan formativ.
Centrarea pe competene reprezint modalitatea care face ca sintagma centrarea pe elev s nu rmn o
lozinc fr coninut.

Proiectarea curriculumului pe competene vine n ntmpinarea cercetrilor din psihologia cognitiv,
conform crora prin competen se realizeaz n mod exemplar tranferul i mobilizarea cunotinelor i a
depriderilor n situaii/contexte noi i dinamice.
Modelul de proiectare curricular centrat pe competene simplific structura curriculumului i asigur o mai
mare eficien a proceselor de predare/nvare i evaluare. Acesta permite operarea la toate nivelurile cu
aceeai unitate: competena, n msur s orienteze demersurile agenilor implicai n procesul de educaie:
conceptorii de curriculum; inspectorii;
specialitii n evaluare; elevii;
profesorii; prinii.
Fr a intra n detalii conceptuale, formulm cteva definiii de lucru necesare pentru explicarea manierei n
care au fost concepute programele colare.
Definim competenele ca fiind ansambluri structurate de cunotine i deprinderi dobndite prin nvare;
acestea permit identificarea i rezolvarea n contexte diverse a unor probleme caracteristice unui anumit
domeniu.
Structura programei colare cuprinde: o not de prezentare, competene generale, competene specifice i
coninuturi, valori i atitudini, sugestii metodologice.
Competenele generale se definesc pe obiect de studiu i se formeaz pe durata nvmntului liceal.
Ele au un grad ridicat de generalitate i complexitate i au rolul de a orienta demersul didactic ctre
achiziiile finale ale elevului.
Competenele specifice se definesc pe obiect de studiu i se formeaz pe parcursul unui an colar. Ele
sunt derivate din competenele generale, fiind etape n dobndirea acestora. Competenelor specifice li se
asociaz prin program uniti de coninut.
Componenta fundamental a programei este cea referitoare la competene specifice i coninuturi.
Pentru a asigura o marj ct mai larg de acoperire a obiectelor de studiu, s-a pornit de la o difereniere ct
mai fin a etapelor unui proces de nvare. Acestora le corespund categorii de competene organizate n
jurul ctorva verbe definitorii, ce exprim complexe de operaii mentale:
1. Receptarea - concretizat prin urmtoarele concepte operaionale:
-identificarea de termeni, relaii, procese;
- observarea unor fenomene, procese;
- perceperea unor relaii, conexiuni;
- nominalizarea unor concepte;
- culegerea de date din surse variate;
- definirea unor concepte.
2. Prelucrarea primar (a datelor) - concretizat prin urmtoarele concepte operaionale:
- compararea unor date, stabilirea unor relaii;
- calcularea unor rezultate pariale;
- clasificarea datelor;
- reprezentarea unor date;
- sortarea-discriminarea;
- investigarea, descoperirea, explorarea;
- experimentarea.
3.Algoritmizarea - concretizat prin urmatoarele concepte operaionale:
-reducerea la o schem sau model; -anticiparea unor rezultate;
94
-remarcarea unor invariani;
-reprezentarea datelor
-rezolvarea de probleme prin modelare si
algoritmizare.
4.Exprimarea - concretizata prin urmatoarele concepte operaionale:
-descrierea unor stri, sisteme, procese, fenomene;
-generarea de idei;
-argumentarea unor enunuri;
-demonstrarea.
5.Prelucrarea secundar (a rezultatelor) concretizat prin urmatoarele concepte operaionale:
-compararea unor rezultate, date de ieire, concluzii;
-calcularea, evaluarea unor rezultate;
-interpretarea rezultatelor;
-analiza de situaii;
-elaborarea de strategii;
-relaionri ntre diferite tipuri de reprezentri,
ntre reprezentare i obiect.
6.Transferul, care poate fi concretizat prin urmatoarele concepte operaionale:
-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.

Competenele generale ce se urmresc a fi formate la elevi pe parcursul treptei liceale de colarizare
precum i competenele specifice fiecrui an de studiu, derivate din acestea, se stabilesc pornind de la modelul
de generare prin gruparea categoriilor de concepte operaionale in funcie de dominantele avute in vedere.

Valorile i atitudinile apar n mod explicit sub forma unei liste separate in programa fiecrui obiect
de studiu. Ele acoper ntreg parcursul nvmantului liceal i orienteaz dimensiunile axioiogic si
afectiv-atitudinal aferente formrii personalitaiii din perspective fiecrei discipline. Realizarea lor
concret deriv din activitatea didactic permanent a profesorului, constituind un implicit al acesteia.
Valorile si atitudinile au o importan egal n reglarea procesului educativ ca i competenele - care
acoper dimensiunea cognitiva a personalitii - dar se supun altor criterii de organizare didactico-
metodic i de evaluare.

Sugestiile metodologice cuprind recomandri generale privind metodologia de aplicare a programei.
Aceste recomandari se pot referi la:
- desfasurarea efectiv a procesului de predare/nvare, centrat pe formarea de competene:
- identificarea celor mai adecvate metode i activiti de nvare;
- dotri/materiale necesare pentru aplicarea n condiii optime a programei;
- evaluarea continu.

Dincolo de structura unitar a programelor colare, curriculumul naional 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 interveniei profesorului n succesiunea elementelor de coninut, cu condiia asigurrii
coerenei tematice i a respectrii logicii interne a domeniului;
- lipsa prescrierii de la centru a intervalului de timp alocat elementelor de coninut;
- posibilitatea modificrii, a completrii sau a nlocuirii activitilor de nvare, astfel nct acestea s
permit un demers didactic personalizat.

II.Aplicarea programelor colare

Existena unor programe centrate pe achiziiile elevilor determin un anumit sens al schimbrii n didactica
fiecrei discipline. Tabelul de mai jos prezint n antitez caracteristici ale procesului de predare-nvare din
didactica tradiionala i didactica actual.

Criterii Strategii didactice
Orientare tradiional Orientare modern
Rolul elevului Urmrete prelegerea, expunerea, explicaia
profesorului.
Exprim puncte de vedere proprii.
ncearc sa rein i sa reproduc ideile auzite Realizeaz un schimb de idei cu ceilali.
Accept n mod pasiv ideile transmise. Argumenteaz; pune i i pune ntrebri cu sco-
pul de a nelege, de a realiza sensul unor idei
95
Lucreaz izolat. Coopereaz n rezolvarea problemelor i a
sarcinilor de lucru.
Rolul
profesorului
Expune, ine prelegeri. Faciliteaz i modereaz nvarea.
Impune puncte de vedere. Ajut elevii s neleag i s explice punctele
de vedere proprii.
Se consider i se manifest n permanen
ca un printe"'.
Este partener n nvare.
Modul de
realizare a
nvrii
nvarea are loc predominant prin memorare
i reproducere de cunotine, prin apel doar la
exemple clasice", validate.
nvarea are loc predominant prin formare de
competene i deprinderi practice.
nvarea conduce la competiie ntre elevi,
cu scopul de ierarhizare
nvarea se realizeaz prin cooperare.
Evaluarea Vizeaz msurarea i aprecierea cunotinelor
(ce tie elevul).
Vizeaz msurarea i aprecierea competenelor
(ce poate s fac elevul cu ceea ce tie).
Pune accent pe aspectul cantitativ (ct de
mult informaie deine elevul).
Pune accent pe elementele de ordin calitativ
(valori, atitudini).
Vizeaz clasificarea static" a elevilor, Vizeaz progresul n nvare pentru fiecare
elev.

De fapt, diferena dintre didactica tradiional i cea actual const n modul de concepere i
organizare a situaiilor de nvare (riguros dirijate n primul caz i avnd autonomie de diferite grade, n
cel de-al doilea). Altfel spus, o strategie este legitim sau ilegitim nu n general, ci potrivit unor
circumstane concrete; profesorul eficient este acela care tie:
o s selecioneze
o s combine
o s varieze diferite metode
o s aleag strategii adecvate.

III.Proiectarea demersului didactic

Predarea reprezint activitatea profesorului de organizare i conducere a ofertelor de nvare care are
drept scop facilitarea i stimularea nvrii eficiente la elevi.
Proiectarea demersului didactic este acea activitate desfurat de profesor care const n anticiparea
etapelor i a aciunilor concrete de realizare a predrii. Proiectarea demersului didactic presupune:
- lectura personalizat a programelor colare;
- planificarea calendaristic;
- proiectarea secvenial (a unitilor de nvare).

III.1. Lectura personalizat a programelor colare
n contextul noului curriculum, conceptul central al proiectrii didactice este demersul didactic personalizat,
iar instrumentul acestuia este unitatea de nvare. Demersul personalizat exprim dreptul profesorului - ca
i al autorului de manual - de a lua decizii asupra modalitilor pe care le consider optime n creterea
calitii procesului de nvatamant, respectiv, rspunderea personal pentru a asigura elevilor un parcurs colar
individualizat, n funcie de condiii i cerine concrete.

LECTURAREA PROGRAMEI se realizeaz pe orizontal n succesiunea urmtoare:

Competente Competente Coninuturi Activiti
Generale Specifice de nvare

III.2.Planificarea calendaristic

n contextul noului curriculum, planificarea calendaristic este un document administrativ care asociaz
elemente ale programei cu alocarea de timp considerat optim de ctre profesor pe parcursul unui an colar.
n elaborarea planificrilor calendaristice recomandm parcurgerea urmtoarelor etape:
1. Realizarea asocierilor dintre competenele specifice i coninuturi.
2. mprirea n uniti de nvare.
3. Stabilirea succesiunii de parcurgere a unitilor de nvare.
96
4. Alocarea timpului considerat necesar pentru fiecare unitate de nvare, n concordan cu competenele
specifice i coninuturile vizate.
Planificrile pot fi intocmite pornind de la urmtoarea rubricaie

Unitatea colar
Disciplina.. Profesor..
Clasa/Nr. ore pe spt./ ..

Planificare calendaristic
Anul colar..
Uniti de
nvare
Competene
specifice
Coninuturi Nr. de ore
alocate
Sptmna Observatii

In acest tabel:
Unitile de nvare se indic prin titluri (teme) stabilite de ctre profesor.
In rubrica Competene specifice se trec simbolurile competenelor specifice din programa colar.
Continuturile selectate sunt cele extrase din lista de continuturi ale programei.
Numarul de ore alocate se stabileste de catre profesor in funcie de experiena acestuia i de nivelul de achiziii
ale elevilor clasei.
ntregul cuprins al planificrii are valoare orientativ, eventualele modificri determinate de aplicarea
efectiv la clas putnd fi consemnate n rubrica Observaii.
O planificare anual corect ntocmit trebuie s acopere integral programa colar la nivel de competene
specifice i coninuturi.

III.3. Proiectarea unei uniti de nvare

Elementul generator al planificrii calendaristice este unitatea de nvare.
O unitate de nvare reprezint o structur didactic deschis i flexibil,care are urmtoarele caracteristici:
- determin formarea la elevi a unui comportament specific, generat prin integrarea unor competene specifice;
- este unitar din punct de vedere tematic;
- se desfoar n mod sistematic i continuu pe o perioad de timp;
- se finalizeaz prin evaluare.
Detaliem n continuare elementele eseniale ale proiectrii unei uniti de nvare.
Se recomand utilizarea urmtorului format.

Unitatea colar
Disciplina.. Profesor..
Clasa/Nr. ore pe spt./ ..

Proiectul unitii de nvare..
Nr. de ore alocate..

Coninuturi Competene
specifice
Activiti de nvare Resurse Evaluare Observatii

Coninuturi: apar inclusiv detalieri de coninut necesare n explicitarea anumitor parcursuri, respectiv n
cuplarea lor la baza proprie de cunoastere a elevilor.
In rubrica Competene specifice se trec simbolurile competenelor specifice din programa colar
Activitile de nvare pot fi cele din programa colar, completate, modificate sau chiar nlocuite de
altele, pe care profesorul le consider adecvate pentru atingerea obiectivelor propuse.
Rubrica Resurse cuprinde specificri de timp, de loc, forme de organizare a clasei,
material didactic folosit etc.
n rubrica Evaluare se menioneaz instrumentele sau modalitaile de evaluare aplicate la clas.
Finalul fiecrei uniti de nvare presupune Evaluare sumativ.

97
Desi denumirea si alocarea de timp pentru unitile de nvare se stabilesc la nceputul anului colar prin
planificare, este recomandabil ca proiectele unitailor de nvaare s se completeze ritmic pe parcursul anului,
avnd n avans un interval de timp optim pentru ca acestea s reflecte ct mai bine realitatea.
In completarea rubricaiei, se urmarete corelarea elementelor celor cinci coloane. Practic pe baza indicaiilor
din planificare se fac detalierile pe orizontal, ordonnd activitaile n succeesiunea derulrii, raportandu-le la
competene i specificnd resursele necesare bunei desfurri a procesului didactic.
Proiectarea unitii de nvare - ca si a leciei - ncepe prin parcurgerea schemei urmatoare:

n ce scop voi face? Ce voi face? Cu ce voi face? Cum voi face? Ct s-a realizat?

Identificarea
competenelor

Selectarea
coninuturilor

Analiza resurselor

Determinarea activitilor de
nvare

Stabilirea instrumentelor
de evaluare

ConceptuI de unitate de nvare are rolul s materializeze conceptul de demers didactic personalizat,
flexibilizd proiectarea didactic i definind n acest sens pentru practica didactic premise mai bine
fundamentate din punct de vedere pedagogic.
Identificarea unei unitii de nvare se face prin tema acesteia. Stabilirea temei de catre profesor pe baza
lecturii programei, utiliznd surse diverse, este primul pas n identificarea unitilor de nvare n care va fi
imparit materia anului colar, respectiv, n organizarea unu demers didactic personalizat. Temele sunt
enunuri complexe legate de analiza scopurilor nvarii, formulri fie originale, fie preluate din lista de
coninuturi a programei, sau din manual formulri care reflect din partea profesorului o ntelegere profund
a scopurilor activitaii sale, talent pedagogic, inspiraie, creativitate.
Activitile de nvare se consruiesc prin corelarea competenelor cu coninuturile i presupun orientarea
ctre un anumit scop, redat prin tema activitii. In momentul propunerii lor spre rezolvare elevilor,
activitile de nvare vor fi transpuse ntr-o anumit form de comunicare inteligibil nivelului de vrst.
Intr-o abordare pragmatic, resursele cuprind acele elemente care asigur cadrul necesar pentru buna
desfaurare a activitailor de nvare. Astfel, profesorul va meniona n aceast rubric forme de organizare a
clasei (tipuri de interaciuni ale resurselor umane), mijloace de nvamant, alocarea de timp, precum i orice
alte elemente pe care le consider utile n derularea scenariului didactic.
In condiiile noului curriculum, lectura programei i a manualelor nu mai este n mod obligatoriu liniar.
Programa trebuie parcurs n mod necesar de ctre toi , dar ea, ca i manualele se pliaz unei citiri personale
i adaptate. Asupra coninuturilor programei profesorul poate interveni prin regruparea lor sub temele
unitilor de nvare pe care le-a stabilit.
III.4. Proiectarea activitii de evaluare se realizeaz concomitent cu proiectarea demersului de
predare/nvare i n deplin concordan cu acesta. Cteva ntrebri utile n proiectarea instrumentelor de
evaluare sunt urmatoarele:
Care sunt competenele din programa colar, pe care trebuie s le dobndeasc elevii?
Care sunt performanele minime, medii i superioare pe care le pot atinge elevii, pentru a demonstra
c au atins aceste competene?
Care este specificu colectivului de elevi pentru care mi propun evaluarea?
Cnd i n ce scop evaluez?
Pentru ce tipuri de evaluare optez?
Cu ce instrumente voi realiza evaluarea?
Cum voi proceda pentru ca fiecare elev sa fie evaluat prin tipuri de probe ct mai variate astfel nct
evaluarea s fie ct mai obiectiv?
Cum voi folosi datele oferite de instrumentele de evaluare administrate, pentru a elimina eventualele
blocaje constatate n formarea elevilor i pentru a asigura progresul scolar al fiecaruia dintre ei?

PREDICTIV (INIIAL)
FORMATIV (CONTINU)
SUMATIV (FINAL)
TIPURI
DE
EVALUARE
98

Adeseori, evaluarea formativ este nlocuit cu evaluarea curent, n accepiunea tradiional de notare
ritmic, constnd n probe stereotipe precum dictri, calcule, compuneri, diverse tipuri de exerciii etc., care
sunt apreciate prin note n mod aproximativ, fr interes n ceea ce privete nivelul cognitiv, afectiv,
psihomotor, relaional. O astfel de evaluare are n vedere doar unele tipuri de comportamente, de obicei
nerelevante pentru personalitatea elevului i neglijeaz aspecte importante ca: gndirea, imaginaia,
atitudinea de responsabilitate, adoptarea unor metode proprii de lucru, competena de comunicare i de
relaionare etc.
Ceea ce este generalizat n evaluarea curent din coli este stocarea n memorie a abstraciilor i
promptitudinea reproducerii acestora. Multe cunotine i capaciti care necesit evaluare sunt ignorate, dei
sunt, n egal msur, variabile importante ale nvrii, cum ar fi: atitudinea elevului fa de nvare, fa de
disciplina de studiu, fa de educator i fa de interrelaiile din interiorul colectivului de elevi, modul n care
elevul nva (sistematic sau sporadic), modul cum abordeaz cunotinele pentru a rezolva probleme
practice, specifice vieii cotidiene etc.
Focalizat pe unitatea de nvare, evaluarea ar trebui s asigure evidenierea progresului nregistrat de
elev n raport cu sine nsui, pe drumul atingerii competenelor prevzute n program. Este important s fie
evaluat nu numai cantitatea de informaie de care dispune elevul, ci, mai ales, ceea ce poate el s fac
utiliznd ceea ce tie sau ceea ce intuiete.
In acest sens, cteva aspecte 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 potenialului de care dispun elevii i conduce la
perfecionarea continu a stilului i a metodelor proprii de nvare;
- realizarea unui echilibru dinamic ntre evaluarea scris i evaluarea oral: aceasta din urm, dei
presupune un volum mare de timp pentru aprecierea tuturor elevilor i blocaje datorate emoiei sau timiditii,
prezint avantaje deosebite, ca: realizarea interaciunii elev-profesor, demonstrarea comportamentului
comunicativ i de inter-relaionare a elevului.
- folosirea cu mai mare frecven a metodelor de autoevaluarei evaluare prin consultare n grupuri mici.
n raport cu momentele realizrii evalurii, n proiectul unitii de nvare apar specificaii: evaluare
iniial, formativ sau sumativ.
Fiecare activitate de evaluare a rezultatelor colare trebuie nsoit n mod sistematic de o autoevaluare a
procesului pe care profesorul l-a desfurat cu toi elevii i cu fiecare elev. Numai astfel pot fi stabilite
modalitile prin care poate fi reglat, de la o etap la alta, activitatea de nvare / formare a elevilor n mod
difereniat.
III.4.1. Tipuri de itemi
Item = <ntrebare> + <formatul acesteia> + <rspunsul ateptat>

Teoria i practica evalurii evideniaz mai multe citerii pe baza crora pot fi clasificai itemii. Unul dintre
criteriile cel mai des utilizate este acela al gradului de obiectivitate oferit n corectare. n funcie de acest
criteriu, itemii pot fi clasificai n trei mari categorii:
COMPLEMENTARE
TRADIIONALE
METODE I
INSTRUMENTE
DE
EVALUARE
Probe scrise
Probe orale
Probe practice
Observarea sistematic a elevilor
Investigaia
Proiectul
Portofoliul
Tema pentru acas
Tema de lucru n clas
Autoevaluarea
99
a. Itemii obiectivi asigur un grad de obiectivitate ridicat n msurarea rezultatelor colare i testeaz un
numr mare de elemente de coninut ntr-un interval de timp relativ scurt. Rspunsul ateptat este bine
determinat, ca i modalitatea de notare a acestuia.
b. Itemii semiobiectivi permit ca rspunsul ateptat s nu fie totdeauna unic determinat, modalitatea de
corectare i notare inducnd uneori mici diferene de la un corector la altul. Acetia testeaz o gam mai
variat de capaciti intelectuale, oferind n acelai timp posibilitatea de a utiliza i materiale auxiliare n
rezolvarea sarcinilor de lucru propuse.
c. Itemii subiectivi (cu rspuns deschis) solicit un rspuns amplu, permind valorificarea capacitilor
creative ale elevilor. Acetia sunt relativ uor de construit, principala problem constituind-o modul de
elaborare a schemei de notare astfel nct s se poat obine unitate i uniformitate la nivelul corectrii.
a. Itemi obiectivi
Fie c este vorba de activiti de proiectare i programare (Informatic), fie c este vorba de activiti de
utilizare i combinare a instrumentelor informatice (Tehnologia Informaiei), lucrul cu calculatorul implic
formulri standardizate, lipsite de echivoc, itemii obiectivi i cei semiobiectivi repezentnd instrumente de
evaluare fracvent aplicate la aceste discipline.
Itemii obiectivi sunt caracterizai prin:
structurarea sarcinilor propuse i standardizarea formatului lor de prezentare;
corelarea strict a sarcinilor cu obiectivele de evalurii;
capacitatea de a testa un numr mare de elemente de coninut ntr-un timp relativ scurt;
obiectivitate privind aprecierea rspunsului;
posibilitatea asocierii cu un sistem de notare extrem de simplu: punctajul aferent se acord integral, se
acord parial conform unei reguli (formule) de calcul sau nu se acord deloc (n funcie de rspunsul
ateptat);
rolul secundar pe care l au de a obinui elevul cu formulri standard, tiinifice, elemente utile n
construirea rspunsurilor pentru itemii semiobiectivi i subiectivi.
a.1. Itemi cu alegere dual
Alegerea dual presupune formularea unei cerine cu dou variante complementare de rspuns
(Adevrat/Fals, Da/Nu, Corect/Incorect etc.).
Se pot verifica prin intermediul itemilor cu alegere dual:
cunotinele legate de corectitudinea sintactic a unor expresii (comenzi, instruciuni, notaii etc.);
nelegerea semnificaiei unor noiuni din terminologia de specialitate (denumiri, instrumente de
prelucrare, metode de rezolvare, proprieti etc.)
recunoaterea unor explicaii, definiii, sau imagini.
Itemii de acest tip se prezint sub forma unor ntrebri sau enunuri, efortul elevului reducndu-se la
identificarea unui rspuns din dou posibile. Achiziiile evaluate prin itemii cu alegere dual sunt de regul
rudimentare. Fac excepie enunurile care pun n eviden justificri ale unor proprieti, operaii sau reguli,
justificri care necesit achiziii cognitive superioare. Tot n categoria itemilor cu alegere dual se pot realiza
cerine care necesit din partea elevului operaii de anticipare a efectului unei operaii prin aplicarea unui
sistem riguros de cunotine ntr-un context nou. Acetia sunt itemii cu cel mai nalt grad de dificultate.
Atragem atenia asupra faptului c lipsa firului rou care pune n eviden elementele sistematice ntlnite
n utilizarea unui produs soft (chiar i n cazul unui soft de baz) conduc la un experimentalism accentuat
care mpiedic formarea capacitii elevului de a se adapta situaiilor noi, neexersate.
Factorul de discriminare fiind ns extrem de mic, elevul va putea obine un rezultat acceptabil la un test format
numai din astfel de itemi alegnd la ntmplare un rspuns dintre cele dou admise pentru fiecare item n parte.
De obicei, itemii cu alegere dual sunt formulai n combinaie cu itemi subiectivi de tipul Justificai...,
Scriei varianta corect..., Explicai n ce const eroarea... etc. n aceste cazuri, o parte din punctaj este
alocat justificrii.
Pentru proiectarea corect a itemilor cu alegere dual este necesar respectarea urmtoarelor cerine:
formularea clar a enunului, fr ambiguiti sau formulri incomplete;
dac se solicit aprecierea cu ADEVRAT/FALS, se vor evita enunurile foarte generale;
selectarea unor enunuri relevante pentru domeniul de cunoatere sau categoria de competene testat
(uneori, efortul de a realiza enunuri fr echivoc duce la elaborarea de itemi nesemnificativi din
punct de vedere educaional sau tiinific);
se va evita utilizarea unor enunuri negative, acestea conducnd la raionamente ce folosesc dubla
negaie, inducnd un grad nalt de ambiguitate;
100
se vor evita enunurile lungi i complexe, prin eliminarea elementelor redundante inutile n raport cu
ideea enunului i cerina itemului; nu se va folosi un limbaj academic, o terminologie foarte
specializat sau o construcie lingvistic stufoas i greoaie;
se va evita introducerea a dou idei ntr-un singur enun, cu excepia cazului n care se dorete
evidenierea relaiei dintre acestea;
enunurile vor fi aproximativ egale ca lungime;
enunurile adevrate sau false s fie aproximativ egale ca numr, dar nu exact egale, deoarece acesta
ar putea constitui un indiciu dup care elevul ncearc s ghiceasc rspunsul corect.
a.2. Itemi de tip pereche
Itemii de tip pereche solicit stabilirea unor corespondene ntre informaiile distribuite pe dou coloane.
Prima coloan conine informaii de tip enun (premise), cea de-a doua coloan coninnd informaii de tip
rspuns. Elevului i se solicit s asocieze fiecare enun cu un unic rspuns.
Cele dou coloane sunt precedate de instruciuni de asociere n care i se explic elevului tehnica de
formare a perechilor (s uneasc printr-o linie, s rescrie perechile asociate sau doar elementele lor de
identificare etc.) i se precizeaz dac un rspuns poate fi folosit la mai mult de un enun (dac funcia de
asociere este injectiv sau nu), eventual dac exist rspunsuri care nu vor fi folosite niciodat (dac funcia de
asociere este surjectiv sau nu).
Se verific prin intermediul itemilor de tip pereche capacitatea elevului de a stabili corelaii ntre:
funcii i instrumente;
simboluri i concepte;
termeni i definiii;
probleme i metode de rezolvare.
Itemii de acest tip permit abordarea unui volum mare de informaie ntr-un interval de timp relativ redus.
Factorul de discriminare este ceva mai mare dect n cazul itemilor cu alegere dual, strategia de asociere la
ntmplare neconducnd dect n situaii foarte rare la un rezultat acceptabil privind rezultatul testului.
Pentru proiectarea corect a itemilor de tip de pereche este necesar respectarea urmtoarelor cerine:
utilizarea unui material omogen, dintr-o sfer relativ restrns;
utilizarea unui numr inegal de premise i rspunsuri, astfel nct, dac elevul asociaz corect n-1
enunuri dintre cele n date, s nu rezulte automat rspunsul pentru cel de-al n-lea enun;
aranjarea listei de rspunsuri (mai ales dac sunt multe) ntr-o ordine logic, astfel nct cutarea
rspunsului n list s se realizeze ct mai comod;
aranjarea enunurilor n list astfel nct s nu se poat intui o regul de asociere (referinele s fie
ncruciate);
aranjarea coloanelor astfel nct acestea s ncap n ntregime pe aceeai pagin.
a.3. Itemi cu alegere multipl
Itemii cu alegere multipl sunt cele mai utilizate tipuri de itemi, n special n testele standardizate
(bacalaureat, admitere etc.)
Un item cu alegere multipl este format dintr-un enun numit premis sau baz i un numr de opiuni din
care elevul trebuie s aleag un singur rspuns numit cheie. Celelalte rspunsuri, neconforme cu cerina, dar
plauzibile poart numele de distractori.
Se verific prin intermediul itemilor de tip pereche capacitatea elevului de a identifica:
definiii i notaii;
instrumentul adecvat unei prelucrri;
secvene 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 informaie ntr-un interval de timp relativ redus,
oferind posibilitatea evalurii unor achiziii cognitive complexe, dei nu pot msura capacitatea elevului de
a-i organiza i exprima ideile. Sunt forme de testare cu un grad mare de fidelitate, iar factorul de
discriminare este mai mare dect n cazul celorlali itemi obiectivi. Abilitatea profesorului de a elabora
distractori ct mai plauzibili, care s construiasc toate alternativele posibile de a grei, contribuie la reuita
aplicrii testelor cu alegere multipl. Erorile comise de elevi ofer profesorului informaii suplimentare
necesare n autoreglarea procesului de nvmnt.
O categorie de itemi cu alegere multipl solicit rspunsul corect, celelalte variante fiind greite, n timp ce
ali itemi solicit cel mai bun rspuns, pe baza unei discriminri complexe. n aceste cazuri trebuie
101
manifestat grij la formularea cerinei astfel nct criteriul de discriminare a celui mai bun rspuns s
reias clar din enun.
Pentru proiectarea corect a itemilor cu alegere multipl este necesar respectarea urmtoarelor cerine:
stabilirea clar a cerinei, n concordan cu obiectivul de evaluare;
furnizarea tuturor informaiilor necesare n premis, eliminndu-se materialul irelevant;
formularea premisei folosind afirmaii sau ntrebri pozitive;
construirea unor alternative plauzibile, aflate n concordan cu premisa;
construirea itemului astfel nct s existe o singur alternativ corect sau cea mai bun;
construirea unor alternative astfel nct distractorii s fie n mod cert greii sau mai puin buni, iar
varianta cheie s fie n mod cert corect sau cea mai bun;
aranjarea listei de rspunsuri ntr-o ordine logic, astfel nct cutarea rspunsului n list s se
realizeze ct mai comod;
construirea ansamblurilor de itemi cu alegere multipl astfel nct rspunsurile s ocupe poziii diferite
n lista de variante (s nu fie n mod constant al doilea rspuns, de exemplu)
b. Itemi semiobiectivi
Itemii semiobiectivi formeaz o categorie de instrumente de evaluare ce solicit construirea parial sau
total a unui rspuns pe baza unei sarcini definite.
Itemii semiobiectivi sunt caracterizai prin:
posibilitatea de a testa o gam mai larg de capaciti intelectuale i rezultate ale nvrii;
crearea unor situaii cognitive de nivel mai ridicat prin solicitarea de elaborare a rspunsului i nu de
alegere a lui dintr-o mulime prestabilit, ca n cazul itemilor obiectivi;
raportarea parial subiectiv a profesorului n raport cu rspunsul formulat (rspunsul poate fi scris
ordonat sau dezordonat, formularea poate fi mai clar sau mai neclar, termenii folosii se pot ncadra n
nite standarde tiinifice sau pot fi variante particulare ale acestora etc.)
posibilitatea asocierii unui sistem de notare n care pot s intervin situaii neprevzute (rspunsuri
neateptate, care comport raportri noi la barem).
b.1. Itemi cu rspuns scurt / de completare
Itemii cu rspuns scurt solicit ca elevul s formuleze un rspuns scurt sau s completeze o
afirmaie astfel nct aceasta s capete sens sau s aib valoare de adevr.
Se pot verifica prin intermediul itemilor cu rspuns scurt i de completare:
cunoaterea unor noiuni, expresii de specialitate, simboluri, notaii etc.;
recunoaterea 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 nct s se realizeze o finalitate precizat.
Itemii cu rspuns scurt se prezint cel mai des sub forma unor ntrebri. Ei solicit un rspuns sub o form
restrns (un numr, un simbol, un cuvnt, o expresie, o propoziie sau fraz concis).
Itemii de completarea se prezint sub forma unui enun, unei afirmaii incomplete. Ei solicit gsirea
cuvntului sau sintagmei care completeaz i d sens enunului respectiv.
Pentru proiectarea corect a itemilor cu rspuns scurt / de completare este necesar respectarea
urmtoarelor cerine:
formularea enunului astfel nct s admit un rspus scurt, exprimat cu precizie;
formularea enunului astfel nct acesta s admit un singur rspuns corect, pe ct posibil;
rezervarea unor spaii pentru rspuns care s sugereze numrul de cuvinte ateptate (dac acest lucru nu
reprezint un indiciu), nu i dimensiunea lor;
vizarea unui rspuns care s reprezinte o sintez de cunotine sau un rezultat al nelegerii unei situaii
i mai puin o reproducere a unor informaii.
b.2. ntrebri structurate
ntrebrile structurate solicit, printr-un sistem de subntrebri relative la o tem comun, rspunsuri de tip
obiectiv, rspunsuri scurte sau de completare prin care se pot evalua cunotinele complexe referitoare la
tema respectiv fr a solicita elaborarea unui rspuns deschis (eseu).
Se pot verifica prin intermediul ntrebrilor structurate:
capacitatea de a urmri, recunoate, adapta i construi un algoritm pe o tem dat sau un program ntr-un
limbaj de programare;
102
capacitatea de a realiza din aproape n aproape o prelucrare complex utiliznd un mediu de lucru informatic.
O ntrebare structurat poate s conin materiale suport i informaii suplimentare ce se adaug treptat,
conferind procesului de evaluare varietate, complexitate i gradualitate. Se pot verifica totodat cunotine,
dar i priceperi i deprinderi sporind gradul de obiectivitate n raport cu itemii cu rspuns deschis.
Subntrebrile ce formeaz itemul permit creterea progresiv a dificultii cerinelor, dar este recomandat ca
subntrebrile s fie independente, adic rspunsul la o ntrebare s nu depind de rspunsul la ntrebrile
precedente. Proiectarea lor necesit atenie, pricepere i timp.
Pentru proiectarea corect a ntrebrilor strucutrate este necesar respectarea urmtoarelor cerine:
redactarea subntrebrilor astfel nct acestea s solicite rspunsuri simple la nceput crescnd pe
parcurs dificultatea acestora;
formularea unor subntrebri autoconinute (al cror rspuns corect s nu depind de rspunsul corect
la una dintre ntrebrile precedente;realizarea concordanei dintre enunul general (tema ntrebrii) i
subntrebrile formulate.
c. Itemi subiectivi (cu rspuns deschis)
Itemii subiectivi formeaz o categorie de instrumente de evaluare ce vizeaz creativitatea elevului,
originalitatea i caracterul personal al rspunsului. Dei sunt uor de formulat, itemii subiectivi ridic
probleme privind obiectivitatea evalurii.
Itemii subiectivi sunt caracterizai prin:
abordare global a unei sarcini asociate unui obiectiv ce nu poate fi evaluat prin intermediul itemilor obiectivi;
crearea unor situaii cognitive de nivel foarte ridicat prin solicitarea de a realiza interaciuni reale i
complexe ntre cunotine, abiliti i deprinderi;
raportarea subiectiv a profesorului n raport cu rspunsul formulat;
necesitatea predefinirii unor criterii privind baremul de corectare i notare, criterii clare, judicioase i
puternic anticipative;
posibilitatea, n cazul n care baremul nu a prevzut toate situaiile de interpretare i construire a
rspunsului, a unor elemente noi (rspunsuri neateptate) care comport reanalizarea baremului.
n cazul informaticii i tehnologiei informaiei se pot elabora itemi subiectivi de tip eseu (structurat sau liber)
i itemi de tip problem (care necesit proiectare, redactare i uneori implementare a rezolvrii).
c.1. Itemi de tip eseu
Itemii de tip eseu pot fi structurai sau liberi. Itemii structurai sunt construii astfel nct rspunsul ateptat s
fie orientat cu ajutorul unor elemente din enun (indicii privind ordinea de tratare, numrul de linii,
formularea rspunsului, ideile care trebuie s fie atinse etc.). Un eseu liber nu furnizeaz n enun nici un fel
de indicaii sau constrngeri, elevul avnd libertatea s-i strucutreze cum consider i cum poate materialul
pe care-l solicit enunul. Acest tip de eseu comport operaii de maxim complexitate (analiz, sintez,
sistematizare i restructurare) lsnd fru liber fanteziei i capacitilor creative ale elevului.
Deoarece la informatic elementele de creativitate se manifest mai ales prin rezolvri de probleme i
proiecte, iar n cazul tehnologiei informaiei prin teme practice i proiecte, itemii de tip eseu preferai sunt cei
structurai, un eseu liber nefiind necesar dect rar, pentru anumite teme cu un volum mai mare de elemente
informative n raport cu achiziiile operaionale.
Se pot verifica prin intermediul itemilor de tip eseu:
cunotinele globale legate de stuctura sistemelor de calcul, sisteme de operare, evoluia istoric a
sitemelor hard i soft, principiile de utilizare a unei anumite aplicaii, etapele conceptuale ale proiectrii
unei aplicaii etc.
capacitile de sistematizare a unor elemente prin construirea unor scheme sau reprezentri grafice.
Itemii de tip eseu se prezint sub forma unor cerine generale nsoite eventual (pentru eseurile structurate)
de indicii privind tratarea cerinei. Se pot aduga restricii privind ntinderea n timp sau spaiu (numr
rnduri, pagini, paragrafe etc.) sau privind forma de prezentare a rspunsului.
c.2. Itemi de tip problem
Rezolvarea unei probleme presupune soluionarea unei situaii conflictuale generat de neconcordane ivite
ntre sistemul de achiziii i situaiile concrete descrise de un enun. Aceste neconcordane sunt generate
uneori de nepotrivirea ntre contextul general al cunotinelor i situaiile particulare n care acestea trebuie
s fie aplicate. Alteori achiziiile sunt dobndite prin experimente (situaii particulare) i, pentru a fi aplicate
n cu totul alte situaii, acestea trebuie s fie ridicate la un nalt nivel de abstractizare i generalizare.
103
Rezolvarea de probleme este o activitate specific i des utilizat la disciplina Informatic,
elementele gndirii algoritmice, metodele de rezolvare i tehnicile de implementare fiind supuse unui tir
sistematic de probleme prin care acestea s formeze competene reale de programare.
Capacitile cognitive superioare legate de aplicare creativ, gndire divergent, descoperirea condiiilor
interne, alegerea modelului adecvat etc. sunt verificate prin itemi de acest tip. Obiectivele urmrite prin
utilizarea rezolvrii de probleme sunt:
- obinerea informaiilor necesare rezolvrii problemei;
-formularea i testarea ipotezelor;
-descrierea metodei de rezolvare a problemei;
-elaborarea unui raport despre rezultatele obinute;
-posibilitatea de generalizare i transfer a tehnicilor
de rezolvare.
104
Cerine suplimentare asociate unei probleme pot pune n eviden capacitatea elevului de a estima eficiena unei
rezolvri, de a construi un algoritm conform unor criterii (limita de memorie, numr de instruciuni 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 prelucrrile numerice ntlnite la matematic, fizic sau n alte domenii, o
formulare a enunului care s se caracterizeze prin coeren.
Enunurile pot fi formulate abstract, la obiect sau pot crea un context care trebuie modelat pentru a
se ajunge la rezolvarea propriu-zis. Povestea n spatele creia se ascunde problema are de cele mai multe
ori conotaii practice, descriind situaii concrete de prelucrare, amintind c rolul programatorului este acela
de a ordona iniial informaia i operaiile specifice unui anumit context i abia dup aceea de a elabora
algoritmul, de a implementa i verifica programul corespunztor.
Aspecte de aceeai natur se ntlnesc i n domeniul utilizrii calculatorului, la Tehnologia
informaiei, cnd beneficiarul formuleaz un enun i utilizatorul trebuie s-i aleag programul de aplicaie
adecvat, din cadrul programului s-i aleag obiectele i instrumentele potrivite, s proiecteze, pe pai,
prelucrarea astfel nct produsul (documentul, prezentarea, raportul etc.) s rspund cerinelor i s fie
realizat n timp record. Aspectele reale de concepie, de creativitate i gndire divergent intervin la
realizarea machetelor, a prezentrilor etc.
Evaluarea prin rezolvare de probleme la informatic ridic uneori probleme din punctul de vedere al
ntocmirii baremului de corectare. Unele tendine exagerate tind s impun o corectare pe principiul:
problem=program funcional corect (pornind de la premisa c un program care aproape merge e ca un
avion care aproape zboar). Se recomand totui ca baremul de corectare s cuprind fraciuni din punctaj
pentru diferitele aspecte pe care le comport rezolvarea unei probleme la informatic: corectitudinea
sintactic, structurarea datelor i declararea variabilelor, structurarea programului, corectitudinea
algoritmului, eficiena algoritmului, tratarea unor situaii limit, eventual explicarea metodei aplicate (chiar
daca a fost aplicat greit) etc.
Se pot verifica prin intermediul itemilor de rezolvare de probleme:
concepia unor algoritmi de rezolvare a problemelor elementare;
asimilarea unui algoritm general prin adaptarea lui astfel nct s rezolve o problem particular;
capacitatea de a alege structurile de program i de date adecvate rezolvrii unei probleme;
abilitatea de a implementa programul, de a-l depana, de a-l testa i, n funcie de erorile aprute, de a
reconsidera elementele de sintax ale programului, strategiile de structurare a datelor sau nsui
algoritmul de rezolvare (n partea practic a probei);
capacitatea de a organiza volume mari de date cu ajutorul bazelor de date;
discernmntul n a alege un algoritm mai eficient (conform unuia dintre din criteriile studiate: numr
operaii, spaiu de memorie utilizat)
III.4.2. Metode complementare de evaluare
Metodele complementare de evaluare reprezint instrumente suplimentare, nestandardizate, de evaluare
dispunnd de forme specifice cum ar fi: investigaia, referatul, portofoliul, proiectul, observarea
sistematic a activitii elevului i autoevaluarea.
Metodele complementare realizeaz actul evalurii n strns legtur cu procesul educativ, prin
ntreptrundere cu etapele acestuia, urmrind n special capacitile cognitive superioare, motivaiile i
atitudinea elevului n demersul educaional.
Metodele alternative de evaluare se caracterizeaz prin urmtoarele:
capacitatea de a transforma relaia profesor-elev inducnd un climat de colaborare i parteneriat;
posibilitatea transformrii procesului de evaluare prin nlocuirea tendinei de a corecta i sanciona prin
aceea de a soluiona erorile semnalate;
posibilitatea de a deprinde elevul cu mecanismele de aurocorectare i autoeducare necesare i n procesul
de integrare social;
utilizarea mai ampl a tehnicilor i mijloacelor didactice;
caracterul sumativ, realizat prin evaluarea cunotinelor, capacitilor i atitudinilor pe o periad mai
lung de timp i dintr-o arie mai larg;
caracterul formativ, realizat prin valorificarea atitudinii elevului n raport cu propria sa evaluare;
capacitatea de a realiza o evaluare individualizat (observare sistematic);
capacitatea de a educa spiritul de echip prin activiti de grup (investigaii, proiecte);
105
caracterul profund integrator realizat prin interdisciplinaritate, educare i instruire mutilateral.
1.Investigaia
Investigaia este o metod de evaluare i nvare utilizat foarte des la disciplina Tehnologie informaiei i
numai ocazional la disciplina Informatic.
Organizarea unei activiti de evaluare i nvare prin metoda investigaiei presupune:
valorificarea metodei de nvare prin descoperire;
studiul unor documentaii complementare, experimentarea unor instrumente de prelucrare
nestandard, compararea i generalizarea unor tehnici i metode utilizate n tehnologie prin cercetarea
altor izvoare sau prin utilizarea altor instrumente echivalente;
extrapolarea cunotinelor dobndite i verificarea ipotezelor formulate;
solicitarea unor cunotine sau deprinderi dobndite la alte dicipline prin adaptarea creatoare a
acestora la cerinele temei de investigaie.
n cele mai multe dintre cazuri investigaia trebuie s fie organizat ca munc independent depus de elev,
dirijat i sprijinit de profesor. Tehnologia informaiei, cu multitudinea de aplicaii software din domenii
att de variate, este un teren ideal pentru desfurarea investigaiilor. Elevul cerceteaz posibilitile unei
aplicaii (de exemplu, aplicaia romneasc de tip agend MyCount difuzat pe Internet): citete explicaiile
asociate butoanelor, opiunile din meniuri, informaiile din Help, experimenteaz operaiile propuse de
aplicaie imaginnd utilitatea practic a acestora i formuleaz concluzii generale referitoare la acel soft
(utilitate, spaiul ocupat pe disc sau n memorie, spaiul ocupat de produsele construite cu ajutorul lui,
calitatea grafic i funcional a interfeei). Investigaii mai rafinate pot realiza elevii iniiai n programare i
n sisteme de operare care disting mult mai multe aspecte n spatele produsului soft investigat (eficien,
posibilitate de dezvoltare, configurare, conflicte cu alte programe etc.).
Pentru organizarea activitilor de investigaie, profesorul va urmri:
formularea general a temei;
asigurarea surselor bibliografice sau tehnice necesare;
formularea unor indicaii care s direcioneze activitatea elevilor;
urmrirea activitii elevului n sensul utilizrii eficiente i creatoare a materialului de investigat;
sprijinirea elevilor sau grupurilor de elevi care ntmpin dificulti n nelegerea temei sau a metodelor
specifice de studiu;
ncurajarea i evidenierea activitilor creatoare desfurate de elevi, a descoperirilor neateptate.

2. Referatul i proiectul

Referatul reprezint o form de mbinare a studiului individual cu activitate de prezentare i argumentare.
Tema referatului, nsoit de bibliografie i alte surse de documentare (Internet, vizite etc.), este tratat n
mod independent de ctre elev i susinut apoi n faa colegilor sau altui auditoriu mai larg. Varietatea
universului informatic (a limbajelor i tehnicilor de programare, a aplicaiilor din domeniul TIC, a noutilor
hardware etc.) justific utilizarea acestei forme de studiu i evaluare la clas, att la Tehnologia informaiei
ct i la Informatic. Dac studiul aferent i rezultatul studiului prezint interes i din punct de vedre practic,
rezultatul fiind un program (o aplicaie) sau un produs TI complex (rezultatul aplicrii creatoare a
instrumentelor informatice), dac bibliografia propus este mai bogat i etapele de proiectare (concepie),
implementare i testare necesit un timp mai ndelungat, lucrarea poart numele de proiect.
Organizarea unei activiti de evaluare i nvare prin intermediul referatelor i proiectelor presupune:
valorificarea metodei de nvare prin descoperire;
studiul unor materiale suplimentare i izvoare de informare diverse n scopul mbogirii i activizrii
cunotinelor din domeniul studiat sau domenii conexe, prin completri de coninut ale programei sau
prin aducerea n atenie a unei problematici complet noi;
structurarea informaiei corespunztoare unui referat ntr-un material ce poate fi scris, ilustrat sau
prezentat pe calculator; activitile de concepere, organizare, experimentare, reproiectare (dac este
cazul), dezvoltare i elaborare a documentaiei aferente necesit planificarea unor etape de elaborare i
o strategie de lucru, n cazul proiectului;
prezentarea referatului sau proiectului de ctre elevul sau elevii care l-au elaborat, acesta (sau un
reprezentant al grupului) trebuind s-l susin, s fie capabil s dea explicaii suplimentare, s
rspund la ntrebri etc.
Referatul este de regul o lucrarea de mai mic amploare, dar mai structurat i mai bogat n
informaii dect o tem de munc independent aferent leciei curente. Proiectul este o lucrare mai ampl a
106
crei tem este comunicat sau aleas din timp, elaborarea unui proiect putnd s dureze de la 1-2 sptmni
pn la 2-3 luni sau chiar un semestru. Proiectul poate fi elaborat n grup, cu o distribuire judicioas a
sarcinilor ntre membrii grupului.
Referatul poate fi utilizat la Informatic i n egal msur la Tehnologia informaiei temele referatelor
viznd cel mai des domenii de actualitate n producia sofware sau n domeniul TIC.
Pentru a realiza o evaluare pe baz de referate, profesorul:
va formula teme clare, de complexitate medie, preciznd pe ct posibil amploarea lucrrii (cte pagini,
durata maxim necesar prezentrii etc.)
va recomanda sau asigura sursele bibliografice i de informare necesare;
i va rezerva suficient timp (n perioada de evaluare sau la sfritul unor uniti de nvare) pentru ca
elevii nsrcinai cu elaborarea referatelor s-i poat prezenta referatul;
va supraveghea discuiile purtate cu elevii asupra coninutului referatului.
Pentru a realiza o evaluare pe baz de proiecte, profesorul:
va formula teme practice, de complexitate sporit, lsnd celor care elaboreaz proiectul mult libertate
n a improviza, adapta i interpreta cerina ntr-un mod personal;
va stabili un termen final i, n funcie 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 sfritul unor uniti de nvare) pentru ca
elevii nsrcinai cu elaborarea proiectelor s-i poat prezenta rezultatul proiectrii;
va supraveghea discuiile purtate cu elevii asupra proiectului.

3. Portofoliul
Portofoliul reprezint o metod complex de evaluare n care un rezultat al evalurii este elaborat pe baza
aplicrii unui ansamblu variat de probe i instrumente de evaluare.
Prin multitudinea de forme i momente n care se desfoar testarea elevului, rezultatul final converge
ctre valoarea real a acestuia, sesiznd elementele de progres sau regres, ilustrnd preocuparea pentru
lmurirea neclaritilor, oferind o imagine de ansamblu asupra nivelului cunotinelor, gradului de formare a
abilitilor i gradului de raportare atitudinal pe care acesta o are fa de tema evaluat. Portofoliul este
realizat pe o periad mai ndelungat, de la un semestru, un an, pn la un ciclu de nvmnt.
Coninutul unui portofoliu este reprezentat de rezultatele la: lucrri scrise sau practice, teme pentru
acas, investigaii, referate i proiecte, observarea sistematic la clas, autoevaluarea elevului, chestionare de
atitudini etc. La Tehnologia informaiei portofoliul se poate constitui dintr-o colecie de lucrri practice
realizate pe calculator, fiecare viznd anumite aspecte de utilizare.
Alegerea elementelor ce formeaz portofoliul este realizat de ctre profesor (astfel nct acestea s ofere
informaii concludente privind pregtirea, evoluia, atitudinea elevului) sau chiar de ctre elev (pe
considerente de performan, preferine etc.)
Structurarea evalurii sub forma de portofoliu se dovedete deosebit de util, att pentru profesor, ct i
pentru elev sau prinii acestuia.
Pentru a realiza o evaluare pe baz de potofoliu, profesorul:
va comunica elevilor intenia de a realiza un portofoliu, adaptnd instrumentele de evaluare ce constituie
centrul de greutate ale portofoliului la specificul disciplinei;
va alege componentele ce formeaz portofoliul, dnd i elevului posibilitatea de a aduga piese pe care le
consider relevante pentru activitatea sa;
va evalua separat fiecare pies a portofoliului n momentul realizrii ei, dar va asigura i un sistem de
criterii pe baza crora s realizeze evaluarea global i final a portofoliului;
va pune n eviden evoluia elevului, particularitile de exprimare i de raportare a acestuia la aria vizat;
va integra rezultatul evalurii portofoliului n sistemul general de notare.

4. Observarea sistematic a activitii i comportamentului elevilor
Fia de observare a activitii i comportamentului elevului nregistreaz informaii legate de
particularitile personalitii elevului manifestate n procesul didactic, de achiziiile evaluate spontan
(rspunsuri sporadice, atitudini semnificative etc.), de progresul nregistrat de acesta. Profesorul construiete
aceast fi n vederea individualizrii procesului sumativ de evaluare, dar i a celui de nvare.
Pe baza fiei de evaluare se poate realiza i orientarea colar i profesional a elevului. Informaiile din fia
personal au caracter parial secret, parte dintre ele fiind comunicate elevului i prinilor acestuia.
107
Un model orientativ de fi de observare conine:
Date generale despre elev (nume, prenume, vrst, climat educativ, condiii materiale, particulariti
socio-comportamentale);
Particulariti ale proceselor intelectuale (gndire, limbaj, imaginaie, memorie, atenie, spirit de
observaie etc.);
Aptitudini i interese manifestate;
Particulariti afectiv-motivaionale;
Trsturi de temperament;
Atitudini i relaionare (cu sine nsui, cu materia studiat, cu colegii)
Consideraii privind evoluia aptitudinilor, atitudinilor, intereselor i nivelului de integrare.
Prin stabilirea copmpetenelor generale ale disciplinei i achiziiile cognitive i comportamentale vizate
de aceasta, fia de observare poate s conin i considerente legate de atingerea i formarea competenelor
specifice. Completarea fiei se realizeaz n timp ntr-un ritm adecvat specificului activitilor de la disciplina,
din anul i de la clasa respectiv, dar i n funcie de implicarea i de ritmul individual al elevului.

IV. . Proiectul unitii de nvare - Proiectul de lecie ?
Fa de proiectarea tradiional centrat pe lecie (ora de curs) - proiectarea unitii de nvare are urmatoarele
avantaje:
creeaz un mediu de nvare coerent n care ateptrile elevilor devin clare pe termen
mediu i lung;
implic elevii n ,,proiecte de nvatare personale" pe termen mediu si lung - rezolvare de
probleme complexe, luare de decizii complexe, cu accent pe explorare i reflecie;
implic profesorul ntr-un ,,proiect didactic" pe termen mediu i lung, cu accent pe
ritmurile de nvare proprii ale elevilor;
d perspectiva leciilor, conferind acestora o structur specific, n funcie de secvena
unitii de nvare n care se afl.
Proiectul de lecie - conceput ca document separat - este recunoscut ca o formalitate consumatoare de timp
i energie. Proiectul unei uniti de nvare conine suficiente elemente pentru a oferi o imagine asupra fiecrei
ore. Ca urmare, n tabelul care sintetizeaza proiectarea unitatii de nvare se pot delimita prin linii orizontale
(punctate) spatiile corespunzatoare unei ore de curs. Astfel, pentru fiecare lecie, proiectul unitii de nvare
ofer date referitoare la elementele de coninut i competenele vizate, la care se raporteaz anumite activiti
de nvare; totodat, sunt indicate resurse materiale, forme de organizare a clasei etc., pentru fiecare activitate
precum i instrumente de evaluare necesare la nivelul leciei (orei). In consecin, dac proiectul unitii de
nvare este bine construit, nu mai este necesar detalierea la nivelul proiectului de lecie.
Lecia este neleas ca o component operaional (Cum?) pe termen scurt a unitii de nvare. Dac
unitatea de nvare ofer ntelegerea procesului din perspectiv strategic, lecia ofer nelegerea procesului
din perspectiva operativ, tactic. Proiectul unitii de nvare trebuie s ofere o derivare simpl a leciilor
componente. Ca urmare, trecerea de la unitatea de nvare - o entitate supraordonat - la o lecie component
trebuie s permit o ,,replicare" n acelai timp functional (De ce?), structural (Cu ce?) i operaional
(Cum?) a unitaii de nvare, la o scar temporal mai mic i ntr-un mod subordonat.
Acest mod de tratare orientat ctre scopuri precise caracterizeaz organizarea att a unitii de nvare ct i a
leciei.

lntroducere n Programarea .Net lramework
Navodari, 20-80 augusL 2007
www.microsoft.com/romania/educatie
http.//msdn2.microsoft.com/en-us/express/defauIt.aspx

Manual C

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Manual C

Încărcat de

Drepturi de autor:

Formate disponibile

Grup elaborare suporL curs.

Nua Dumitriu-Lupan, lnspecLor General M.L.C.1.

S-ar putea să vă placă și