Introducere in .Net Framework - Suport de Curs Pentru Profesori

Autori, în ordine alfabetică:
Adrian Niţă
profesor, Colegiul Naţional „Emanuil Gojdu”, Oradea
Maria Niţă
profesor, Colegiul Naţional „Emanuil Gojdu”, Oradea
Nicolae Olăroiu
profesor, Colegiul Naţional „B.P. Hașdeu”, Buzău Suport de curs pentru profesori
Rodica Pintea
profesor, Liceul „Grigore Moisil”, București (capitolul 1)
Cristina Sichim
profesor, Colegiul Naţional „Ferdinand I”, Bacău
Daniela Tarasă
Inspector Informatică, ISJ Bacău
Coordonatori:
Mihai Tătăran
cadru didactic asociat, Universitatea Politehnică Timișoara
Nușa Dumitriu-Lupan
inspector General MECT
Petru Jucovschi
Developer Community Lead, Microsoft România
Introducere în
.Net Framework
Ediţia 2008
Cerinþe de sistem
Arhitectura suportatã:
• x86
• x64 (WOW)
Sistem de operare suportat:

• Microsoft Windows XP
• Microsoft Windows Server 2003
• Windows Vista
Cerinþe Hardware:
• Minimum: CPU 1.6 GHz, RAM 192 MB, Rezoluþie Monitor 1024x768, Disc 5400 RPM
• Recomandat: CPU 2.2 GHz sau mai puternic, RAM 384 MB sau mai mult, rezoluþie monitor 1280x1024,
Disc 7200 RPM sau mai mult.
• Windows Vista: CPU 2.4 GHz, RAM 768 MB, Spaþiu liber disc 1.3 GB pentru instalare completã
Resurse ºi Instrumente:
• www.microsoft.ro/ark - Academic Resource Kit, colecþie de instrumente software ºi resurse
educaþionale.
Cuvânt Înainte
Stimaþi profesori,
Introducere în .NET Framework este un curs dezvoltat în cadrul programului

Microsoft Parteneri pentru Educaþie, în colaborare cu un grup de profesori de infor-
maticã din România. Pânã la sfârºitul anului ºcolar 2007-2008 va fi disponibil în pe
situl Microsoft România, în pagina Secþiuni pentru educaþie.
Cursul vã propune sã exploraþi tehnologia .NET, cea mai rãspânditã platformã de

aplicaþii software. Aveþi posibilitatea sã studiaþi soluþii software ºi sã dezvoltaþi
aplicaþii ce pot fi trimise la concursuri sau pot fi integrate în proiecte educaþionale.
Suportul de curs este publicat în douã versiuni. Cea pentru elevi cuprinde doar
componenta de specialitate. Versiunea pentru profesori cuprinde pe lângã compo-
nenta de specialitate ºi pe cea metodicã de predare.
Suportul de curs poate fi descãrcat gratuit ºi folosit exclusiv în procesul educaþional.
Scopul acestei iniþiative a programului Parteneri pentru Educaþie este de a încuraja

dezvoltarea profesionalã a profesorilor ºi de a da un suflu nou experienþei
educaþionale la materia Informaticã.
Împreunã cu partenerii, echipa Microsoft România vã mulþumeºte pentru interesul

pentru studiul tehnologiei .Net.
Sperãm doamnelor ºi domnilor profesori, ca aceste materiale sã vã ajute în predarea

materiei la clasã!
Sanda Foamete
SNR Manager de Proiecte Educaþionale
Microsoft România
Autori, în ordine alfabeticã:
Adrian Niþã, profesor, Colegiul Naþional „Emanuil Gojdu”, Oradea

Maria Niþã, profesor, Colegiul Naþional „Emanuil Gojdu”, Oradea
Nicolae Olãroiu, profesor Colegiul Naþional „B.P. Haºdeu”, Buzãu
Rodica Pintea, profesor, Liceul „Grigore Moisil”, Bucureºti (capitolul 1)
Cristina Sichim, profesor, Colegiul Naþional „Ferdinand I”, Bacãu
Daniela Tarasã, Inspector Informaticã, ISJ Bacãu
Coordonatori:
Mihai Tãtãran, cadru didactic asociat, Universitatea Politehnica din Timiºoara

Nuºa Dumitriu-Lupan, Inspector General MECT
Petru Jucovschi, Developer Community Lead, Microsoft România
Formatul electronic al textului digital: PDF
Editat de BYBLOS SRL sub coordonarea Agora Media SA, pentru Microsoft România. Ediþia 2008.
ISBN: 973-86699-6-0
Notã:
Acest suport de curs este destinat profesorilor ce predau la clasele matematicã-informaticã ºi
matematicã-informaticã intensiv, care au optat în programa ºcolarã, pentru variantele: Programare
orientatã obiect, Progamare vizualã cu C# ºi Programare web cu Asp.Net. Suportul de curs poate fi
utilizat gratuit exclusiv în procesul de predare-învãþare. Este interzisã utilizarea suportului de curs
„Introducere în .Net Framework” pentru scopuri comerciale sau în alte scopuri în afara celui descris
mai sus.
Drepturile de autor asupra suportului de curs „Introducere în .Net Framework” aparþin Microsoft.
Introducere în .Net Framework (Suport de curs) 3
CUPRINS
1 Programarea Orientatã Obiect (POO) cu C# . . . . . . . . . . . . . . . . . . . . . . . . . . . .7
1.1. Evoluþia tehnicilor de programare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7
1.2. Tipuri de date obiectuale. Încapsulare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8
1.3. Supraîncãrcare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9
1.4. Moºtenire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10
1.5. Polimorfism. Metode virtuale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10
1.6. Programare orientatã obiect în C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11
1.7. Declararea unei clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11
1.8. Constructori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12
1.9. Destructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14
1.10. Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14
1.11. Proprietãþi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16
1.12. Evenimente ºi delegãri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .17
1.13. Interfeþe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .19
2. Platforma .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .21

2.1. Prezentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .21
2.2. Compilarea programelor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22
2.3. De ce am alege .NET? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23
3. Limbajul C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25
3.1. Caracterizare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25
3.2. Compilarea la linia de comandã . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25
3.3. Crearea aplicaþiilor consolã . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26
3.4. Structura unui program C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27
3.5. Sintaxa limbajului . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .28
3.6. Tipuri de date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30
3.7. Conversii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .34
3.7.1. Conversii numerice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .34
3.7.2. Conversii între numere ºi ºiruri de caractere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .36
3.7.3. Conversii boxing ºi unboxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .38
3.8. Constante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .39
3.9. Variabile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .39
3.10. Expresii ºi operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .39
3.11. Instrucþiuni condiþionale, de iteraþie ºi de control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40
3.11.1. Instrucþiunea if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40
4 Introducere în .Net Framework (Suport de curs)
3.11.2. Instrucþiunea while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40

3.11.3. Instrucþiunea do – while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .41
3.11.4. Instrucþiunea for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .42
3.11.5. Instrucþiunea switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .42
3.11.6. Instrucþiunea foreach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43
3.11.7. Instrucþiunea break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43
3.11.8. Instrucþiunea continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43
3.11.9. Instrucþiunea goto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .44
3.12. Instrucþiunile try-catch-finally ºi throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .45
4. Programarea web cu ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47

4.1. Introducere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47
4.2. Structura unei pagini ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .48
4.3. Controale Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .50
4.4. Pastrarea informatiilor in aplicatiile web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .51
4.4.1. Pastrarea starii controalelor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .51
4.4.2. Pastrarea altor informatii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .52
4.4.2.1. Profile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .52
4.4.2.2. Session . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .53
4.4.2.3. Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .53
4.4.2.3. Membrii statici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .54
4.4.3. Concluzii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .54
4.5. Validarea datelor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .54
4.5.1. Proprietati comune . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .54
4.5.2. Validatoare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .55
4.6. Securitatea în ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .55
4.6.1. Windows Authentication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
4.6.2. Forms-Based Authentication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
4.6.3. Securizarea unei aplicaþii web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56
4.7. Accesul la o baza de date intr-o pagina web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57
4.8. Resurse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57
5. Programare vizualã . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .59

5.1. Concepte de bazã ale programãrii vizuale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .59
5.2. Mediul de dezvoltare Visual C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61
5.3. Ferestre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62
5.4. Controale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64
5.4.1. Controale form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
5.4.2. Proprietãþi comune ale controalelor ºi formularelor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
5.4.3. Câteva dintre metodele ºi evenimentele Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .66
5.5. System.Drawing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .86
5.6. Validarea informaþiilor de la utilizator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .87
Introducere în .Net Framework (Suport de curs) 5
6. ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89
6.1. Arhitectura ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90
6.2. Furnizori de date (Data Providers) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90
6.3. Connection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90
6.3.1. Exemple de conectare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91
6.3.2. Proprietãþi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91
6.3.3. Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92
6.3.4. Evenimente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92
6.4. Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92
6.4.1. Proprietãþi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93
6.4.2. Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93
6.4.3. Interogarea datelor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
6.4.4. Inserarea datelor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
6.4.5. Actualizarea datelor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
6.4.6. ªtergerea datelor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .96
6.5. DataReader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .99
6.5.1. Proprietãþi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .99
6.5.2. Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .99
6.6. DataAdapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .101
6.6.1. Proprietãþi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102
6.6.2. Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102
6.7. DataSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102
6.8. SqlParameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .104
6.9. Proceduri Stocate (Stored Procedures) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105
6.10. Proiectarea vizualã a seturilor de date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .106
7. MiniGhid Metodologic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .109

I. Programa ºcolarã reper obligatoriu pentru un demers flexibil . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
II. Aplicarea programelor ºcolare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
III. Proiectarea demersului didactic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
III.1. Lectura personalizatã a programelor ºcolare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .113
III.2. Planificarea calendaristicã . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .113
III.3. Proiectarea unei unitãþi de învãþare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
III.4. Proiectarea activitãþii de evaluare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .116
III.4.1. Tipuri de itemi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .118
III.4.2. Metode complementare de evaluare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126
IV. Proiectul unitãþii de învãþare - Proiectul de lecþie? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
V. Curriculum la decizia ºcolii - CDS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
III. Anexe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
III.1. Anexa 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .133
III.2. Anexa 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .137
III.3. Anexa 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .140
7
CAPITOLUL 1
Programarea Orientatã Obiect (POO) cu C#
1.1 Evolutia tehnicilor de programare

• Programarea nestructuratã (un program simplu, ce utilizeazã numai variabile
globale); complicaþiile apar când prelucrarea devine mai amplã, iar datele se multi-
plicã ºi se diversificã.
• Programarea proceduralã (program principal deservit de subprograme cu para-
metri formali, variabile locale ºi apeluri cu parametri efectivi); se obþin avantaje
privind depanarea ºi reutilizarea codului ºi se aplicã noi tehnici privind transferul
parametrilor ºi vizibilitatea variabilelor; complicaþiile apar atunci când la program
sunt asignaþi doi sau mai mulþi programatori care nu pot lucra simultan pe un acelaºi
fiºier ce conþine codul sursã.
• Programarea modularã (gruparea subprogramelor cu funcþionalitãþi similare în
module, implementate ºi depanate separat); se obþin avantaje privind independenþa ºi
încapsularea (prin separarea zonei de implementare, pãstrând vizibilitatea numai asupra
zonei de interfaþã a modulului) ºi se aplicã tehnici de asociere a procedurilor cu datele
pe care le manevreazã, stabilind ºi diferite reguli de acces la date ºi la subprograme.
Se observã cã modulele sunt ”centrate” pe proceduri, acestea gestionând ºi setul

de date pe care le prelucreazã (date+date1 din figurã). Daca, de exemplu, dorim sã
avem mai multe seturi diferite de date, toate înzestrate comportamental cu proce-
durile din modulul module1, aceastã arhitecturã de aplicaþie nu este avantajoasã.
• Programarea orientatã obiect (programe cu noi tipuri ce integreazã atât datele,
cât ºi metodele asociate creãrii, prelucrãrii ºi distrugerii acestor date); se obþin avan-
taje prin abstractizarea programãrii (programul nu mai este o succesiune de
prelucrãri, ci un ansamblu de obiecte care prind viaþã, au diverse proprietãþi, sunt
capabile de acþiuni specifice ºi care interacþioneazã în cadrul programului); intervin

tehnici noi privind instanþierea, 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 operaþii aplicabile acestor date. Considerând, î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. Totuºi se va
þine cont doar de datele semnificative pentru problema datã. Astfel, ”culoarea
ochilor” este irelevantã în acest caz, în timp ce ”data naºterii” poate fi importantã. În
aceeaºi idee, operaþii specifice ca ”se înregistreazã”, ”comandã on-line” pot fi rele-
vante, în timp ce operaþia ”manâncã” nu este, în cazul nostru. Evident, nici nu se pun
în discuþie date sau operaþii nespecifice (”numãrul de laturi” sau acþiunea ”zboarã”).
Operaþiile care sunt accesibile din afara entitãþii formeazã interfaþa acesteia. Astfel,
operaþii interne cum ar fi conversia datei de naºtere la un numãr standard calculat de
la 01.01.1900 nu fac parte din interfaþa tipului de date abstract, în timp ce operaþia
”plaseazã o comandã on-line” face parte, deoarece permite interacþiunea cu alte
obiecte (SITE, STOC etc.)
O instanþã a unui tip de date abstract este o ”concretizare” a tipului respectiv, for-
matã din valori efective ale datelor.
Un tip de date obiectual este un tip de date care implementeazã un tip de date
abstract. Vom numi operaþiile implementate în cadrul tipului de date abstract metode.
Spunem cã datele ºi metodele sunt membrii unui tip de date obiectual. Folosirea unui
astfel de tip presupune: existenþa definiþiei acestuia, apelul metodelor ºi accesul la date.
Un exemplu de-acum clasic de tip de date abstract este STIVA. Ea poate avea ca date:
numerele naturale din stivã, capacitatea stivei, vârful etc. Iar operaþiile specifice pot fi:
introducerea în stivã (push) ºi extragerea din stivã (pop). La implementarea tipului STIVA,
vom defini o structura de date care sã reþinã valorile memorate în stivã ºi câmpuri de date
simple pentru: capacitate, numãr de elemente etc. Vom mai defini metode (subpro-
grame) capabile sã creeze o stivã vidã, care sã introducã o valoare în stivã, sã extragã va-
loarea din vârful stivei, sã testeze dacã stiva este vidã sau dacã stiva este plinã etc.
Crearea unei instanþe noi a unui tip obiectual, presupune operaþii specifice de
”construire” a noului obiect, metoda corespunzãtoare purtând numele de
constructor. Analog, la desfiinþarea unei instanþe ºi eliberarea spaþiului de memorie
CAPITOLUL 1. Programarea orientatã obiect (POO) cu C# 9
aferent datelor sale, se aplicã o metodã specificã numitã destructor1.

O aplicaþie ce utilizeazã tipul obiectual STIVA, va putea construi douã sau mai
multe stive (de cãrþi de joc, de exemplu), le va umple cu valori distincte, va muta va-
lori dintr-o stivã în alta dupã o anumitã regulã desfiinþând orice stivã golitã, pânã ce
rãmâne o singurã stivã. De observat cã toate aceste prelucrãri recurg la datele, con-
structorul, destructorul ºi la metodele din interfaþa tipului STIVA descris mai sus.
Principalul tip obiectual întâlnit în majoritatea mediilor de dezvoltare (Viisual
Basic, Delphi, C++, Java, C#) poartã numele de clasã (class). Existã ºi alte tipuri obiec-
tuale (struct, object). O instanþã a unui tip obiectual poartã numele de obiect.
La implementare, datele ºi metodele asociate trebuie sã fie complet ºi corect de-
finite, astfel încât utilizatorul sã nu fie nevoit sã þinã cont de detalii ale acestei imple-
mentãri. El va accesa datele, prin intermediul proprietãþilor ºi va efectua operaþiile,
prin intermediul metodelor puse la dispoziþie de tipul obiectual definit. Spunem cã
tipurile de date obiectuale respectã principiul încapsulãrii. Astfel, programatorul ce
utilizeazã un tip obiectual CONT (în bancã) nu trebuie sã poarte grija modului cum
sunt reprezentate în memorie datele referitoare la un cont sau a algoritmului prin
care se realizeazã actualizarea soldului conform operaþiilor de depunere, extragere ºi
aplicare a dobânzilor. EL va utiliza unul sau mai multe conturi (instanþe ale tipului
CONT), accesând proprietãþile ºi metodele din interfaþã, realizatorul tipului obiectual
asumându-ºi acele griji în momentul definirii tipului CONT.
Permiþând extensia tipurilor de date abstracte, clasele pot avea la implementare:
• date ºi metode caracterisitice fiecãrui 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: numãrul
de stive generate, numãrul maxim sau numãrul 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ã câte un exemplar al membrului respectiv pentru fiecare instanþã a cla-
sei, membrii statici sunt unici, fiind accesaþi în comun de toate instanþele clasei. Mai
mult, membrii statici pot fi referiþi chiar ºi fãrã a crea vreo instanþã a clasei respective.
1.3. Supraîncãrcare
Deºi nu este o tehnicã specificã programãrii orientatã obiect, ea creeazã un anu-
mit context pentru metodele ce formeazã o clasã ºi modul în care acestea pot fi (ca
orice subprogram) apelate.
Prin supraîncarcare se înþelege posibilitatea de a defini în acelaºi domeniu de
vizibilitate2 mai multe funcþii cu acelaºi nume, dar cu parametri diferiti ca tip ºi/sau ca
numãr. Astfel ansamblul format din numele funcþiei ºi lista sa de parametri reprezin-
tã o modalitate unicã de identificare numitã semnãturã sau amprentã. Supra-
1 Datoritã tehnicii de supraîncãrcare C++, Java ºi C# permit existenþa mai multor constructori
2 Noþiunile generale legate de vizibilitate se considerã cunoscute din programarea proceduralã. Aspectele specifice
ºi modificatorii de acces/vizibilitate pot fi studiaþi din documentaþiile de referinþã C#.
încãrcarea permite obþinerea unor efecte diferite ale apelului în contexte diferite3.
Apelul unei funcþii care beneficiazã, prin supraîncãrcare, de douã sau mai multe
semnãturi se realizeazã prin selecþia funcþiei a cãrei semnãturã se potriveºte cel mai
bine cu lista de parametri efectivi (de la apel).
Astfel, poate fi definitã metoda ”comandã on-line” cu trei semnãturi diferite:
comanda_online(cod_prod) cu un parametru întreg (desemnând comanda unui singur
produs identificat prin cod_prod.
comanda_online(cod_prod,cantitate) cu primul parametru întreg ºi celalalt real
comanda_online(cod_prod,calitate) cu primul parametru întreg ºi al-II-lea caracter.
1.4. Moºtenire
Pentru tipurile de date obiectuale class este posibilã o operaþie de extindere sau
specializare a comportamentului unei clase existente prin definirea unei clase noi ce
moºteneºte datele ºi metodele clasei de bazã, cu aceastã ocazie putând fi redefiniþi
unii membri existenþi sau adãugaþi unii membri noi. Operaþia mai poartã numele de
derivare.
Clasa din care se moºteneºtea se mai numeºte clasã de bazã sau superclasã. Clasa
care moºteneºte se numeºte subclasã, clasã derivatã sau clasã descendentã.
Ca ºi în Java, în C# o subclasã poate moºteni de la o singurã superclasã, adicã avem
de-a face cu moºtenire simplã; aceeaºi superclasã însã poate fi derivatã în mai multe
subclase distincte. O subclasã, la randul ei, poate fi 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 moºtenesc de la clasa de bazã Object.
În contextul mecanismelor de moºtenire trebuie amintiþi modificatorii abstract ºi
sealed aplicaþi unei clase, modificatori ce obligã la ºi respectiv se opun procesului de
derivare. Astfel, o clasã abstractã trebuie obligatoriu derivatã, deoarece direct din ea
nu se pot obþine obiecte prin operaþia de instanþiere, în timp ce o clasã sigilatã
(sealed) nu mai poate fi derivatã (e un fel de terminal în ierarhia claselor). O metodã
abstractã este o metodã pentru care nu este definitã o implementare, aceasta urmând
a fi realizatã în 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 stãri, sã aibã comportamente diferite.
Polimorfismul obiectual5 se manifestã în lucrul cu obiecte din clase aparþinând unei
ierarhii de clase, unde, prin redefinirea unor date sau metode, se obþin membri dife-
3 Capacitatea unor limbaje (este ºi cazul limbajului C#) de a folosi ca "nume" al unui subprogram un operator, repre-
zintã supraîncãrcarea operatorilor. Aceasta este o facilitate care "reduce" diferenþele dintre operarea la nivel abstract
(cu DTA) ºi apelul metodei ce realizeazã acestã operaþie la nivel de implementare obiectualã. Deºi ajutã la sporirea
expresivitãþii codului, prin supraîncãrcarea 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 supraîncãrcãrcãrii
funcþiilor ºi operatorilor.
riþi având însã acelaºi 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 dinamic6, a membrului referit.
De exemplu, dacã este definitã clasa numitã PIESA (de ºah), cu metoda nestaticã
muta(pozitie_initiala,pozitie_finala), atunci subclasele TURN ºi PION trebuie sã
aibã metoda muta definitã în mod diferit (pentru a implementa maniera specificã a
pionului de a captura o piesã ”en passant”7). Atunci, pentru un obiect T, aparþinând
claselor derivate din PIESA, referirea la metoda muta pare nedefinitã. Totuºi mecanis-
mele POO permit stabilirea, în momentul apelului, a clasei proxime cãreia îi aparþine
obiectul T ºi apelarea metodei corespunzãtore (mutare de pion sau turã sau altã
piesã).
Pentru a permite acest mecanism, metodele care necesitã o decizie contextualã (în
momentul apelului), se declarã ca metode virtuale (cu modificatorul virtual). În mod
curent, în C# modificatorului virtual al funcþiei din clasa de bazã, îi corespunde un
specificator override al funcþiei din clasa derivatã ce redefineºte funcþia din clasa de
bazã.
O metodã ne-virtualã nu este polimorficã ºi, indiferent de clasa cãreia îi aparþine
obiectul, va fi invocatã metoda din clasa de bazã.
1.6. Programare orientatã obiect în C#

C# permite utilizarea OOP respectând toate principiile enunþate anterior.
Toate componentele limbajului sunt într-un fel sau altul, asociate noþiunii de clasã.
Programul însuºi este o clasã având metoda staticã Main() ca punct de intrare, clasã
ce nu se instanþiazã. Chiar ºi tipurile predefinite byte, int sau bool sunt clase sigilate
derivate din clasa ValueType din spaþiul System. Pentru a evita unele tehnici de progra-
mare periculoase, limbajul oferã tipuri speciale cum ar fi: interfeþe ºi delegãri.
Versiunii 2.0 a limbajului i s-a adãugat un nou tip: clasele generice8,
1.7. Declararea unei clase

Sintaxa9: [atrib]o [modificatori]o class [nume_clasã] [:clasa_de_bazã]o [corp_clasã]o
Atributele reprezintã informaþii declarative cu privire la entitatea definitã.
Modificatorii reprezintã o secvenþã de cuvinte cheie dintre: public protected internal
private (modificatori de acces) new abstract sealed (modificatori de moºtenire)
Clasa de bazã este clasa de la care moºteneºte clasa curentã ºi poate exista o sin-
gurã astfel de clasã de bazã. Corpul clasei este un bloc de declarãri ale membrilor
clasei: constante (valori asociate clasei), câmpuri (variabile), tipuri de date definite de
6 Este posibil doar în cazul limbajelor ce permit "legarea întârziatã". La limbajele cu "legare timpurie", adresa la care
se face un apel al unui subprogram se stabileºte la compilare. La limbajele cu legare întârziatã, aceastã adresa se sta-
bileste doar in momentul rulãrii, putându-se calcula distinct, în funcþie de contextul în care apare apelul.
7 Într-o altã concepþie, metoda muta poate fi implementatã la nivelul clasei PIESA ºi redefinitã la nivelul subclasei
PION, pentru a particulariza acest tip de deplasare care captureazã piesa peste care trece pionul în diagonalã.
8 echivalentrul claselor template din C++
9 [] din definiþia schematicã semnificã un neterminal, iar o semnificã o componentã opþionalã
utilizator, metode (subprograme), constructori, un destructor, proprietãþi (caracteris-

tici ce pot fi consultate sau setate), evenimente (instrumente de semnalizare), inde-
xatori (ce permit indexarea instanþelor din cadrul clasei respective) ºi operatori.
• constructorii ºi destructorul au ca nume numele clasei proxime din care fac
parte10
• metodele au nume care nu coincid cu numele clasei sau al altor membri (cu
excepþia metodelor, conform mecanismului de supraîncãrcare)
• metodele sau constructorii care au acelaºi nume trebuie sã difere prin semnã-
turã11
• se pot defini date ºi metode statice (caracteristice clasei) ºi un constructor static
care se executã la iniþializarea clasei propriu-zise; ele formeazã un fel de ”con-
text” al clasei
• se pot defini date ºi metode nestatice (de instanþã) care se multiplicã pentru
fiecare instanþã în parte în cadrul operaþiei de instanþiere; ele formeazã contex-
tele tuturor instanþelor clasei respective
Exemplul urmãtor defineºte o ierarhie de clase (conform figurii alãturate)
public abstract class Copil { }
public class Fetita: Copil { }
public sealed class Baiat: Copil { }
Modificatorul abstract este folosit pentru a desemna faptul cã nu se pot obþine

obiecte din clasa Copil, ci numai din derivatele acesteia (Fetita, Baiat), iar modifica-
torul 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)
1.8. Constructori
Sintaxa:
[atrib]o [modificatori]o [nume_clasã]([listã_param_formali]o)[:iniþializator]o [corp_constr]o
Modificatori: public protected internal private extern
Iniþializator: base([listã_param]o), this([listã_param]o) ce permite invocarea unui
constructor anume12 înainte de executarea instrucþiunilor ce formeazã corpul con-
structorului curent. Dacã nu este precizat niciun iniþializator, se asociazã implicit
iniþializatorul base().
Corpul constructorului este format din instrucþiuni care se executã la crearea unui
10 având în vedere cã ele pot sã facã parte dintr-o clasã interioarã altei clase
11 din semnãturã nefãcând parte specificatorii ref ºi out asociaþi parametrilor
12 Din clasa de bazã (base) sau din clasa insãºi (this)
nou obiect al clasei respective (sau la crearea clasei, în cazul constructorilor cu mo-
dificatorul static).
• pot exista mai mulþi constructori care se pot diferenþia prin lista lor de parametri
• constructorii nu pot fi moºteniþi
• dacã o clasã nu are definit niciun constructor, se va asigna automat constructorul
fãrã parametri al clasei de bazã (clasa object, dacã nu este precizatã clasa de bazã)
Instanþierea presupune declararea unei variabile de tipul clasei respective ºi
iniþializarea acesteia prin apelul constructorului clasei (unul dintre ei, dacã sunt
definiþi mai mulþi) precedat de operatorul new. Acestea se pot realiza ºi simultan într-o
instrucþiune de felul:
[Nume_clasã] [nume_obiect]=new [Nume_clasã] ([listã_param]o)
J Utilizarea unui constructor fãrã parametri ºi a constructorului implicit în clasã

derivatã
public abstract class Copil

{ protected string nume;
public Copil() {nume = Console.ReadLine();} //la iniþializarea obiectului se
citeºte
//de la tastaturã un ºir de caractere ce va reprezenta numele copilului
}
class Fetita:Copil {}
...
Fetita f=new Fetita();
Copil c= new Copil(); //Pentru clasa Copil abstractã, s-ar fi obþinut eroare aici
J Supraîncãrcarea constructorilor ºi definirea explicitã a constructorilor în clase

derivate
public class Copil

{ protected string nume; //datã accesibilã 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 fãrã parametri din clasa de bazã14
//public Fetita(string s):base() {nume=s}
}
...
Copil c1= new Copil(); //se citeste numele de la tastaturã
Copil c2= new Copil(“Codrina”);
Fetita f1=new Fetita();Fetita f2=new Fetita(“Ioana”);
13 Preia ºi specializeazã constructorul al doilea din clasa de bazã

14 Este echivalent cu public Fetita():base(){}
Existã douã motive pentru care definiþia constructorului al treilea din clasa Fetita
este greºitã ºi de aceea este comentatã. Care sunt aceste motive?
1.9. Destructor
Sintaxa: [atrib]o [extern]o ~[nume_clasã] () [corp_destructor]o
Corpul destructorului este format din instrucþiuni care se executã la distrugerea
unui obiect al clasei respective. Pentru orice clasã poate fi definit un singur construc-
tor. Destructorii nu pot fi moºteniþi. În mod normal, destructorul nu este apelat în
mod explicit, deoarece procesul de distrugere a unui obiect este invocat ºi gestionat
automat de Garbagge Collector.
1.10. Metode
Sintaxa:[atrib]o[modificatori]o[tip_returnat][nume]([listã_param_formali]o) [corp_metoda]o
Modificatori: new public protected internal private static virtual abstract sealed
override extern15
Tipul rezultat poate fi un tip definit sau void. Numele poate fi un simplu identifica-
tor sau, în cazul în care defineºte în mod explicit un membru al unei interfeþe, numele
este de forma [nume_interfata].[nume_metoda]
Lista de parametri formali este o succesiune de declarãri despãrþite prin virgule,
declararea unui parametru având sintaxa: [atrib]o [modificator]o [tip] [nume]
Modificatorul unui parametru poate fi ref (parametru de intrare ºi ieºire) sau out
(parametru care este numai de ieºire). Parametrii care nu au niciun 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 poate reduce la un semn ;
Semnãtura fiecãrei metode este formatã din numele metodei, modificatorii aces-
teia, numãrul ºi tipul parametrilor16
Numele metodei trebuie sã difere de numele oricãrui alt membru care nu este
metodã.
La apelul metodei, orice parametru trebuie sã aibã acelaºi 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 corespunzãtoare unei clase
15 Poate fi folosit cel mult unul dintre modificatorii static, virtual ºI override ; nu pot apãrea împreunã new ºi over-
ride, 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 semnãturã (amprentã) nu fac parte tipul returnat, numele parametrilor formali ºi nici specificatorii ref ºi out.
public class Copil

{ public const int nr_max = 5; //constantã
public static int nr_copii=0; //câmp simplu (variabilã)
static Copil[] copii=new Copil[nr_max]; //câmp de tip tablou (variabilã)
public static void adaug_copil(Copil c) //metodã
{ copii[nr_copii++] = c;
if (nr_copii==nr_max) throw new Exception(“Prea multi copii”);
}
public static void afisare() //metodã
{
Console.WriteLine(“Sunt {0} copii:”, nr_copii);
for (int i = 0; i<nr_copii; i++)
Console.WriteLine(“Nr.{0}. {1}”, i+1, copii[i].nume);
} ...17
}
...
Fetita c = new Fetita();Copil.adaug_copil(c);
referinþa noului obiect se memoreazã în tabloul static copii (caracteristic clasei) ºi

se incrementeazã data staticã nr_copii
Baiat c = new Baiat(); Copil.adaug_copil(c);

Copil c = new Copil(); Copil.adaug_copil(c);
Copil.afisare(); //se afiºeazã o listã cu numele celor 3 copii
Definirea datelor ºi metodelor nestatice corespunzãtoare clasei Copil ºi claselor

derivate
public class Copil

{ ...
public string nume;
public virtual void se_joaca() //virtual à se poate suprascrie la
derivare
{Console.WriteLine(“{0} se joaca.”, this.nume);}
public void se_joaca(string jucaria) //nu permite redefinire18
{Console.WriteLine(“{0} se joaca cu {1}.”, this.nume, jucaria);}
} //supraîncãrcarea metodei se_joaca
class Fetita:Copil
{ public override void se_joaca() //redefinire à comportament polimorfic
{Console.WriteLine(“{0} leagana papusa.”,this.nume);}
}
class Baiat:Copil
{ public override void se_joaca()
{Console.WriteLine(“{0} chinuie pisica.”,this.nume);}
}
...
17 Se are în vedere ºi constructorul fãrã parametri definit ºi preluat implicit în subclasele din cadrul primului exem-
plu din subcapitolul 1.8: public Copil() {nume = Console.ReadLine();}
18 Decât cu ajutorul modificatorului new pentru metoda respectivã în clasa derivatã
Fetita c = new Fetita();c.se_joaca(“pisica”);c.se_joaca(); //polimorfism

Baiat c = new Baiat();c.se_joaca(“calculatorul”);c.se_joaca(); //polimorfism
Copil c = new Copil();c.se_joaca(); //polimorfism
Pentru a evidenþia mai bine comportamentul polimorfic, propunem secvenþa

urmãtoare î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. Proprietãþi
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}
Observaþiile privind modificatorii ºi numele metodelor sunt valabile ºi în cazul pro-
prietãþilor.
Metodele de acces sunt douã: set ºi get. Dacã proprietatea nu este abstractã sau
externã, poate sã aparã una singurã dintre cele douã metode de acces sau amân-
douã, în orice ordine.
Este o manierã de lucru recomandabilã aceea de a proteja datele membru (câm-
puri) ale clasei, definind instrumente de acces la acestea: pentru a obþine valoarea
câmpului respectiv (get) sau de a memora o anumitã valoare în câmpul respectiv
(set). Dacã metoda de acces get este perfect asimilabilã cu o metodã ce retuneazã o
valoare (valoarea datei pe care vrem s-o obþinem sau valoarea ei modificatã conform
unei prelucrãri suplimentare specifice problemei în cauzã), metoda set este asimi-
labilã cu o metodã care un parametru de tip valoare (de intrare) ºi care atribuie (sau
nu, în funcþie de context) valoarea respectivã câmpului. Cum parametrul corespunzã-
tor valorii transmise nu apare în structura sintacticã a metodei, este de stiut cã el este
implicit identificat prin cuvântul value. Dacã se supune unor condiþii specifice proble-
mei, se face o atribuire de felul câmp=value.
Definirea în clasa Copil a proprietãþii Nume, corespunzãtoare câmpului protejat ce
reþine, sub forma unui ºir de caractere, numele copilului respctiv. Se va observã cã
proprietatea este moºtenitã ºi de clasele derivate Fetita ºi Bãiat19.
public class Copil

{...
string nume; // este implicit protected
public string Nume //proprietatea Nume
{ get
{ if(char.IsUpper(nume[0]))return nume; else return nume.ToUpper();}
set { nume = value; }
}
19 Desigur cã proprietatea care controleazã accesul la câmpul identificat prin nume se poate numi cu totul altfel (pro-
prietatea Nume fiind uºor de confundat cu câmpul 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 delegãri

Evenimentele sunt membri ai unei clase ce permit clasei sau obiectelor clasei sã
facã notificãri, adicã sã anunþe celelalte obiecte asupra unor schimbãri petrecute la
nivelul stãrii lor. Clasa furnizoare a unui eveniment publicã (pune la dispoziþia altor
clase) acest lucru printr-o declarare event care asociazã evenimentului un delegat,
adicã o referinþã cãtre o funcþie necunoscutã cãreia i se precizeazã doar antetul,
funcþia urmând a fi implementatã la nivelul claselor interesate de evenimentul
respectiv. Este modul prin care se realizeazã comunicarea între obiecte. Tehnica prin
care clasele implementeazã metode (handler-e) ce rãspund la evenimente generate
de alte clase poartã numele de tratare a evenimentelor.
Sintaxa: [atrib]o [modificatori]o event [tip_delegat] [nume]
Modificatorii permiºi sunt aceiaºi ca ºi la metode.
Tipul delegat este un tip de date ca oricare altul, derivat din clasa sigilatã Delegate,
din spaþiul System. Definirea unui tip delegat se realizeazã prin declararea:
[atrib]o [modificatori]o delegate [tip_rezultat] [nume_delegat] ([listã_param_for-
mali]o)
Un delegat se poate defini ºi în afara clasei generatoare de evenimente ºi poate
servi ºi altor scopuri în afara tratãrii evenimentelor. Prezentãm î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 delegãri:
public delegate bool pereche_ok(object t1, object t2);

public class Vector
{ public const int nmax = 4;
public int[] v=new int[nmax];
public Vector()
{ Random rand = new Random();
for (int i = 0; i < nmax; i++) v[i] = rand.Next(0,5);
}
public void scrie()
20 De observat cã în exemplul anterior (subcapitolul 1.10), câmpul nume era declarat public, pentru a permite acce-
sul "general" la câmpul respectiv de date. Iar metodele ºi constructorii foloseau identificatorul nume ºi nu propri-
etatea Nume.
{ for (int i = 0; i < nmax; i++) Console.Write(“{0}, “, v[i]);

Console.WriteLine();
}
public bool aranj(pereche_ok ok)//ok e o delegare cãtre o funcþie necunoscutã
{ for (int i = 0; i < nmax-1; i++)
if (!ok(v[i], v[i + 1])) return false;
return true;
}
}
Dacã în clasa-program21 se adugã funcþiile (exprimând douã “reguli de aranjare”

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:
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 aplicaþiei. Se defineºte un tip delegat TD (sã zicem) cu niºte parametri de
interes22 ºi un eveniment care are ca asociat un delegat E (de tip TD)23. Orice obiect x
din clasa Vector are un membru E (iniþial null). O clasã C interesatã sã fie înºtiinþatã
când se face vreo interschimbare într-un vector pentru a genera o animaþie, de exem-
plu, va implementa o metodã M ce realizeazã animaþia ºi va adãuga pe M (prin inter-
mediul unui delegat) la x.E24. Cumulând mai multe astfel de referinþe, x.E ajunge un
fel de listã de metode (handlere). În clasa Vector, în metoda sort, la interschimbarea
valorilor a douã componente se invocã delegatul E. Invocarea lui E realizeazã de fapt
activarea tuturor metodelor adãugate la E.
Care credeþi cã sunt motivele pentru care apelãm la evenimente în acest caz, când
pare mult mai simplu sã apelãm direct metoda M la orice interschimbare?
21 Independent de definiþia clasei Vector

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)
1.13. Interfeþe
Interfeþele sunt foarte importante în programarea orientatã pe obiecte, deoarece
permit utilizarea polimorfismului într-un sens mai extins.O interfaþã este o compo-
nentã a aplicaþiei, asemãnãtoare unei clase, ce declarã prin membrii sãi (metode, pro-
prietãþi, evenimente ºi indexatori) un ”comportament” unitar aplicabil mai multor
clase, comportament care nu se poate defini prin ierarhia de clase a aplicaþiei.
De exemplu, dacã vom considera arborele din figura urmãtoare, în care AVERE
este o clasã abstractã, iar derivarea claselor a fost conceputã urmãrind proprietãþile
comune ale componentelor unei averi, atunci o clasã VENIT nu este posibilã,
deoarece ea ar moºteni de la toate clasele evidenþiate, iar moºtenirea multiplã nu
este admisã în C#.
Pentru metodele din cadrul unei interfeþe nu se dã nici o implementare, ci sunt pur
ºi simplu specificate, implementarea lor fiind furnizatã de unele dintre clasele apli-
caþiei25. Nu existã instanþiere în cazul interfeþelor, dar se admit derivãri, inclusiv
moºteniri multiple.
În exemplul nostru, se poate defini o interfaþã VENIT care sã conþinã antetul unei
metode calc (sã zicem) pentru calculul venitului obþinut, fiecare dintre clasele care
implementeazã interfaþa VENIT fiind obligatã sã furnizeze o implementare (dupã o
formulã de calcul specificã) pentru metoda calc din interfaþã. Orice clasã care doreºte
sã adere la interfaþã trebuie sã implementeze toate metodele din interfaþã. Toate
clasele care moºtenesc dintr-o clasã care implementeazã o interfaþã moºtenesc, evi-
dent, metodele respective, dar le pot ºi redefini (de exemplu, clasa Credit_acordat
redefineºte metoda calc din clasa Investiþie, deoarece formula de calcul implemen-
tatã acolo nu i se ”potriveºte” ºi ei26).
De exemplu, dacã presupunem cã toate clasele subliniate implementeazã interfaþa
VENIT, atunci pentru o avere cu acþiuni la douã firme, un imobil închiriat ºi o
25 Acele clase care "aderã" la o interfaþã spunem cã "implementeazã" interfaþa respectivã
26 Dacã în sens polimorfic spunem cã Investiþie este ºi de tip Bani ºi de tip Avere, tot aºa putem spune cã o clasã care
implementeazã interfaþa VENIT ºi clasele derivate din ea sunt ºi de tip VENIT
depunere la bancã, putem determina venitul total:
Actiune act1 = new Actiune();Actiune act2 = new Actiune();

I_inchiriat casa = new I_inchiriat();Depunere dep=new Depunere();
Venit[] venituri = new Venit()[4];
venituri[0] = act1; venituri[1] = act2;
venituri[2] = casa; venituri[3] = dep;
...
int t=0;
for(i=0;i<4;i++) t+=v[i].calc();
Gãsiþi douã motive pentru care interfaþa VENIT ºi rezovarea de mai sus oferã o
soluþie mai bunã decât: t=act1.calc()+act2.calc()+casa.calc()+dep.calc().
21
CAPITOLUL 2
Platforma .NET
2.1 Prezentare
.NET este un cadru (Framework) de dezvoltare software unitarã care permite
realizarea, distribuirea ºi rularea aplicaþiilor-desktop Windows ºi aplicaþiilor WEB.
Tehnologia .NET pune laolaltã mai multe tehnologii (ASP, XML, OOP, SOAP,
WDSL, UDDI) ºi limbaje de programare (VB, C++, C#, J#) asigurând totodatã atât
portabilitatea codului compilat între diferite calculatoare cu sistem Windows, cât ºi
reutilizarea codului în programe, indiferent de limbajul de programare utilizat.
.NET Framework este o componentã livratã împreunã cu sistemul de operare
Windows. De fapt, .NET 2.0 vine cu Windows Server 2003, se poate instala pe versi-
unile anterioare, pânã 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 aplicaþii pe platforma .NET este bine sa avem 3 componente
esenþiale:
• 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, aplicaþiilor Web ºi apli-
caþiilor desktop Windows.
Când dezvoltãm aplicaþii .NET, putem utiliza:
• Servere specializate - un set de servere Enterprise .NET (din familia SQL Server
2000, Exchange 2000 etc), care pun la dispoziþie funcþii de stocare a bazelor de
date, email, aplicaþii B2B (Bussiness to Bussiness – comerþ electronic între
partenerii unei afaceri).
• Servicii Web (în special comerciale), utile în aplicaþii care necesitã identificarea
utilizatorilor (de exemplu, .NET Passport - un mod de 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.)
.NET Framework
Componenta .NET Framework stã la baza tehnologiei .NET, este ultima interfaþã
între aplicaþiile .NET ºi sistemul de operare ºi actualmente conþine:

Limbajele C#, VB.NET, C++ ºi J#. Pentru a fi integrate în platforma .NET toate aces-
te limbaje respectã niºte specificaþii OOP numite Common Type System (CTS). Ele au
ca elemente de bazã: clase, interfeþe, delegãri, tipuri valoare ºi referinþã, iar ca
mecanisme: moºtenire, polimorfism ºi tratarea excepþiilor.
Platforma comunã de executare a programelor numitã Common Language
Runtime (CLR), utilizatã de toate cele 4 limbaje. CTS face parte din CLR.
Ansamblul de biblioteci necesare în realizarea aplicaþiilor desktop sau Web numit
Framework Class Library (FCL).
Arhitectura .NET Framework
Componenta .NET Framework este formatã din compilatoare, biblioteci ºi alte exe-
cutabile utile în rularea aplicaþiilor .NET. Fiºierele corespunzãtoare se aflã, în general,
în directorul C:\WINDOWS\Microsoft. NET\Framework\V2.0…. (corespunzãtor versiu-
nii instalate)
2.2. Compilarea programelor

Un program scris într-unul dintre limbajele .NET conform Common Language
Specification (CLS) este compilat în Microsoft Intermediate Language (MSIL sau IL).
Codul astfel obþinut are extensia exe, dar nu este direct executabil, ci respectã for-
matul unic MSIL.
CLR include o maºinã virtualã asemãnãtoare cu o maºinã Java, ce executã
instrucþiunile IL rezultate în urma compilãrii. Maºina foloseºte un compilator special
JIT (Just In Time). Compilatorul JIT analizeazã codul IL corespunzãtor apelului unei
metode ºi produce codul maºinã adecvat ºi eficient. El recunoaºte secvenþele de cod
pentru care s-a obþinut deja codul maºinã adecvat permiþând reutilizarea acestuia
fãrã recompilare, ceea ce face ca, pe parcursul rulãrii, aplicaþiile .NET sã fie din ce în
ce mai rapide.
Faptul cã programul IL produs de diferitele limbaje este foarte asemãnãtor are ca
rezultat interoperabilitatea între aceste limbaje. Astfel, clasele ºi obiectele create
într-un limbaj specific .NET pot fi utilizate cu succes în altul.
CAPITOLUL 2. Platforma .NET 23
În plus, CLR se ocupã de gestionarea automatã a memoriei (un mecanism imple-

mentat î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ã .NET Framework este imple-
mentarea unui standard numit Common Language Infrastructure (http://www.ecma-
international.org/publications/standards/Ecma-335.htm), ceea ce permite rularea
aplicaþiilor .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 ).
2.3. De ce am alege .NET?

În primul rând pentru cã ne oferã instrumente pe care le putem folosi ºi în alte pro-
grame, oferã acces uºor la baze de date, permite realizarea desenelor sau a altor ele-
mente grafice. Spaþiul de nume System.Windows.Forms conþine instrumente (con-
troale) ce permit implementarea elementelor interfeþei grafice cu utilizatorul.
Folosind aceste controale, puteþi proiecta ºi dezvolta rapid ºi interactiv, elementele
interfeþei grafice. Tot .NET vã oferã clase care efectueazã majoritatea sarcinilor uzuale
cu care se confruntã programele ºi care plictisesc ºi furã timpul programatorilor,
reducând astfel timpul necesar dezvoltãrii aplicaþiilor.
25
CAPITOLUL 3
Limbajul C#
3.1. Caracterizare
Limbajul C# fost dezvoltat de o echipã restrânsã de ingineri de la Microsoft, echipã
din care s-a evidenþiat Anders Hejlsberg (autorul limbajului Turbo Pascal ºi membru
al echipei care a proiectat Borland Delphi).
C# este un limbaj simplu, cu circa 80 de cuvinte cheie, ºi 12 tipuri de date prede-
finite. El permite programarea structuratã, modularã ºi orientatã obiectual, conform
perceptelor moderne ale programãrii profesioniste.
Principiile de bazã ale programãrii pe obiecte (ÎNCAPSULARE, MOªTENIRE,
POLIMORFISM) sunt elemente fundamentale ale programãrii C#. În mare, limbajul
moºteneºte sintaxa ºi principiile de programare din C++. Sunt o serie de tipuri noi de
date sau funcþiuni diferite ale datelor din C++, iar în spiritul realizãrii unor secvenþe
de cod sigure (safe), unele funcþiuni au fost adãugate (de exemplu, interfeþe ºi
delegãri), diversificate (tipul struct), modificate (tipul string) sau chiar eliminate
(moºtenirea multiplã ºi pointerii cãtre funcþii). Unele funcþiuni (cum ar fi accesul
direct la memorie folosind pointeri) au fost pãstrate, dar secvenþele de cod corespun-
zãtoare se considerã ”nesigure”.
3.2. Compilarea la linia de comandã

Se pot dezvolta aplicaþii .NET ºi fãrã 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 edi-
tor de text, fiºierele se salveazã cu extensia cs, apoi se compileazã la linie de comandã.
Astfel, se scrie în Notepad programul:
using System;
class primul
{
static void Main()
{ Console.WriteLine(“Primul program”);
Console.ReadKey(true);
}
}
Dacã se salveazã fiºierul primul.cs, în directorul WINDOWS\Microsoft.NET\

Framework\V2.0, atunci scriind la linia de comandã: csc primul.cs se va obþine fiºierul
primul.exe direct executabil pe o platformã .NET.
3.3. Crearea aplicaþiilor consolã

Pentru a realiza aplicaþii în mediul de dezvoltare Visual Studio, trebuie sã instalãm
o versiune a acestuia, eventual versiunea free Microsoft Visual C# 2005/2008 Express
Edition de la adresa http://msdn.microsoft.com/vstudio/express/downloads/default.
aspx. Pentru început, putem realiza aplicaþii consolã (ca ºi cele din Borland Pascal sau
Borland C).
Dupã lansare, alegem opþiunea New Project din meniul File. În fereastra de dialog
(vezi figura), selectãm pictograma Console Application, dupã care, la Name, intro-
ducem numele aplicaþiei noastre.
Fereastra în care scriem programul se numeºte implicit Programs.cs ºi se poate

modifica prin salvare explicitã (Save As). Extensia cs provine de la C Sharp.
În scrierea programului suntem asistaþi de IntelliSense, ajutorul contextual.
Compilarea programului se realizeazã cu ajutorul opþiunii Build Solution (F6) din

meniul Build. Posibilele erori de compilare sunt listate în fereastra Error List.
Efectuând dublu clic pe fiecare eroare în parte, cursorul din program se poziþioneazã
pe linia conþinând eroarea.
CAPITOLUL 3. Limbajul C# 27
Rularea programului se poate realiza în mai multe moduri: rapid fãrã asistenþã de
depanare (Start Without Debugging Shift+F5) , rapid cu asistenþã de depanare (Start
Debugging F5 sau cu butonul din bara de instrumente), rulare pas cu pas (Step
Into F11 ºi Step Over F12) sau rulare rapidã pânã la linia marcatã ca punct de între-
rupere (Toggle Breakpoint F9 pe linia respectivã ºi apoi Start Debugging F5). În-
cetarea urmãririi pas cu pas (Stop Debugging Shift+F5) permite ieºirea din modul
depanare ºi revenirea la modul normal de lucru. Toate opþiunile de rulare ºi depanare
se gãsesc în meniul Debug al mediului.
Fereastra de cod ºi ferestrele auxiliare ce ne ajutã în etapa de editare pot fi vizua-

lizate alegând opþiunea corespunzãtoare din meniul View. Ferestrele auxiliare utile în
etapa de depanare se pot vizualiza alegând opþiunea corespunzãtoare din meniul
Debug/Windows.
3.4. Structura unui program C#

Sã începem cu exemplul clasic “Hello World” adaptat la limbajul C#:
1 using System;
2
3 namespace HelloWorld
4 {
5 class Program
6 {
7 static void Main()
8 {
9 Console.WriteLine(“Hello World!”);
10 }
11 }
12 }
O aplicatie C# este formatã din una sau mai multe clase, grupate în spaþii de nume
(namespaces). Un spaþiu de nume cuprinde mai multe clase cu nume diferite având
funcþionalitãþi înrudite. Douã clase pot avea acelaºi nume cu condiþia ca ele sã fie de-
finite în spaþii de nume diferite. În cadrul aceluiaºi spaþiu de nume poate apãrea
definiþia unui alt spaþiu de nume, caz în care avem de-a face cu spaþii de nume imbri-
cate. O clasã poate fi identificatã prin numele complet (nume precedat de numele
spaþiului sau spaþiilor de nume din care face parte clasa respectivã, cu separatorul
punct). În exemplul nostru, HelloWorld.Program este numele cu specificaþie com-
pletã al clasei Program.
O clasã este formatã din date ºi metode (funcþii). 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 aparþine unui spaþiu de nume neinclus în fiºierul curent,
atunci este necesarã precizarea tuturor componentelor numelui: spaþiu.clasã.metodã
sau spaþiu.spaþiu.clasã.metodã etc.
În fiºierul nostru se aflã douã spaþii de nume: unul definit (HelloWorld) ºi unul
extern inclus prin directiva using (System). Console.WriteLine reprezintã apelul
metodei WriteLine definitã în clasa Console. Cum în spaþiul de nume curent este
definitã doar clasa Program, deducem cã definiþia clasei Console trebuie sã se
gãseascã în spaþiul System.
Pentru a facilita cooperarea mai multor programatori la realizarea unei aplicaþii
complexe, existã posibilitatea de a segmenta aplicaþia în mai multe fiºiere numite
assemblies. Într-un assembly se pot implementa mai multe spaþii de nume, iar pãrþi
ale unui aceeaºi spaþiu de nume se pot regãsi în mai multe assembly-uri. Pentru o
aplicaþie consolã, ca ºi pentru o aplicaþie Windows de altfel, este obligatoriu ca una
(ºi numai una) dintre clasele aplicaþiei sã conþinã un „punct de intrare” (entry point),
ºi anume metoda (funcþia) Main.
Sã comentãm programul de mai sus:
linia 1: este o directivã care specificã faptul cã se vor folosi clase incluse în spaþiul
de nume System. În cazul nostru se va folosi clasa Console.
linia 3: spaþiul nostru de nume
linia 5: orice program C# este alcãtuit din una sau mai multe clase
linia 7: metoda Main, „punctul de intrare” în program
linia 9: clasa Console, amintitã mai sus, este folositã pentru operaþiile de
intrare/ieºire. Aici se apeleazã metoda WriteLine din acestã clasã, pentru afiºarea
mesajului dorit pe ecran.
3.5. Sintaxa limbajului

Ca ºi limbajul C++ cu care se înrudeºte, limbajul C# are un alfabet format din litere
mari ºi mici ale alfabetului englez, cifre ºi alte semne. Vocabularul limbajului este for-
mat din acele ”simboluri”27 cu semnificaþii lexicale în scrierea programelor: cuvinte
(nume), expresii, separatori, delimitatori ºi comentarii.
Comentarii
comentariu pe un rând prin folosirea // Tot ce urmeazã dupã caracterele // sunt
considerate, din acel loc, pânã la sfârºitul rândului drept comentariu
27 Este un termen folosit un pic echivoc ºi provenit din traduceriea cuvântului "token"
// Acesta este un comentariu pe un singur rand
comentariu pe mai multe rânduri prin folosirea /* ºi */ Orice text cuprins între
simbolurile menþionate mai sus se considerã a fi comentariu. Simbolurile /* repre-
zintã începutul comentariului, iar */ sfârºitul respectivului comentariu.
/* Acesta este un
comentariu care se
intinde pe mai multe randuri */
Nume
Prin nume dat unei variabile, clase, metode etc. înþelegem o succesiune de carac-
tere care îndeplineºte urmãtoarele 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 decât 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 puþin un caracter (fie el ºi literã
micã ce diferã de aceeaºi literã majusculã)
Convenþii pentru nume:
• în cazul numelor claselor, metodelor, a proprietãþilor, enumerãrilor, interfeþelor,
spaþiilor de nume, fiecare cuvânt care compune numele începe cu majusculã
• în cazul numelor variabilelor dacã numele este compus din mai 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 reprezentând constante, regulile de formare a expresiilor, se-

paratorii de liste, delimitatorii de instrucþiuni, de blocuri de instrucþiuni, de ºiruri de
caractere etc. sunt în mare aceiaºi ca ºi în cazul limbajului C++.
3.6. Tipuri de date

În C# existã douã categorii de tipuri de date:
• tipuri valoare
• tipul simple: byte, char, int, float etc.
• tipul enumerare - enum
• tipul structurã - struct
• tipuri referinþã
• tipul clasã - class
• tipul interfaþã - interface
• tipul delegat - delegate
• tipul tablou - array
Toate tipurile de date sunt derivate din tipul System.Object
Toate tipurile valoare sunt derivate din clasa System.ValueType, derivatã la rân-
dul ei din clasa Object (alias pentru System.Object).
Limbajul C# conþine un set de tipuri predefinite (int, bool etc.) ºi permite definirea
unor tipuri proprii (enum, struct, class etc.).
Tipuri simple predefinite
Tip Descriere Domeniul de valori

object rãdãcina oricãrui tip
string secvenþã de caractere Unicode
sbyte tip întreg cu semn, pe 8 biþi -128; 127
short tip întreg cu semn, pe 16 biþi -32768; 32767
int tip întreg cu semn pe, 32 biþi -2147483648; 21447483647
-9223372036854775808;
long tip întreg cu semn, pe 64 de biþi
9223372036854775807
byte tip întreg fãrã semn, pe 8 biþi 0; 255
ushort tip întreg fãrã semn, pe 16 biþi 0; 65535
uint tip întreg fãrã semn, pe 32 biþi 0; 4294967295
ulong tip întreg fãrã semn, pe 64 biþi 0; 18446744073709551615
tip cu virgulã mobilã, simplã precizie, pe 32 biþi

float -3.402823E+38; 3.402823E+38
(8 pentru exponent, 24 pentru mantisã)
tip cu virgulã mobilã, dublã precizie, pe 64 biþi -1.79769313486232E+308;

double
(11 pentru exponent, 53 -mantisa) 1.79769313486232E+308
-79228162514264337593543950335;
bool tip boolean
79228162514264337593543950335
char tip caracter din setul Unicode, pe 16 biþi
tip zecimal, pe 128 biþi (96 pentru mantisã), 28
decimal
de cifre semnificative
O valoare se asigneazã dupã urmãtoarele reguli:

Sufix Tip
nu are int, uint, long, ulong
u, U uint, ulong
L, L long, ulong
ul, lu, Ul, lU, UL, LU, Lu ulong
Exemple:
string s = "Salut!" float g = 1.234F;

long a = 10; double h = 1.234;
long b = 13L; double i = 1.234D;
ulong c = 12; bool cond1 = true;
ulong d = 15U; bool cond2 = false;
ulong e = 16L; decimal j = 1.234M;
ulong f = 17UL;
Tipul enumerare
Tipul enumerare este un tip definit de utilizator. Acest tip permite utilizarea
numelor care, sunt asociate unor valori numerice. Toate componentele enumerate au
un acelaºi tip de bazã întreg. În cazul în care, la declarare, nu se specificã tipul de bazã
al enumerãrii, atunci acesta este considerat implicit int.
Declararea unui tip enumerare este de forma:
enum [Nume_tip] [: Tip]o

{
[identificator1][=valoare]o,
...
[identificatorn][=valoare]o
}
Observaþii:
• În mod implicit valoarea primului membru al enumerãrii este 0, iar fiecare varia-
bilã care urmeazã are valoarea (implicitã) mai mare cu o unitate decât precedenta.
• Valorile folosite pentru iniþializãri trebuie sã facã parte din domeniul de valori
declarat al tipului
• Nu se admit referinþe circulare:
enum ValoriCirculare
{
a = b,
b
}
Exemplu:
using System;
namespace tipulEnum
{
class Program
{
enum lunaAnului
{
Ianuarie = 1,
Februarie, Martie, Aprilie, Mai, Iunie, Iulie,
August, Septembrie, Octombrie, Noiembrie, Decembrie
}
{
Console.WriteLine(“Luna Mai este a {0}“,
(int)lunaAnului.Mai + “-a luna din an.”);
Console.ReadLine();
}
}
}
În urma rulãrii programului se afiºeazã mesajul:

Luna Mai este a 5-a luna din an.
Tablouri
Declararea unui tablou unidimensional:
Tip[] nume;
Prin aceasta, nu se alocã spaþiu pentru memorare. Pentru a putea reþine date în
structura de tip tablou, este necesarã o operaþie de instanþiere:
nume = new Tip[NumarElemente];
Declararea, instanþierea ºi chiar iniþializarea tabloului se pot face în aceeaºi
instrucþiune:
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 distincþie între tablouri regu-
late ºi tablouri neregulate (tablouri de tablouri)
Declarare în cazul tablourilor regulate bidimensionale:
Tip[,] nume;
Intanþiere:
nume = new Tip[Linii,Coloane];
Acces:
nume[indice1,indice2]
Exemple:
int[,] mat = new int[,] {{1,2,3},{4,5,6},{7,8,9}}; sau
int[,] mat = {{1,2,3},{4,5,6},{7,8,9}};
Declarare în cazul tablourilor neregulate bidimensionale:

Tip[][] nume;
Intanþiere:
nume = new Tip[Linii],[];
nume[0]=new Tip[Coloane1]
...
nume[Linii-1]=new Tip[ColoaneLinii-1]
Acces:
nume[indice1][indice2]
Exemple:
int[][] mat = new int[][] {
new int[3] {1,2,3},
new int[2] {4,5},
new int[4] {7,8,9,1}
}; sau
int[][] mat={new int[3] {1,2,3},new int[2] {4,5},new int[4] {7,8,9,1}};
ªiruri de caractere
Se definesc douã tipuri de ºiruri:
• regulate
• de tip „verbatim”
Tipul regulat conþine între ghilimele zero sau mai multe caractere, inclusiv
secvenþe escape.
Secvenþele 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 rând
\t horizontal tab - tab orizontal
\u caracter unicode
\v vertical tab - tab vertical
\x caracter hexazecimal
În cazul în care folosim multe secvenþe escape, putem utiliza ºirurile verbatim.
Aceste ºiruri pot sã conþinã orice fel de caractere, inclusiv caracterul EOLN. Ele se
folosesc în special în cazul în care dorim sã facem referiri la fiºiere ºi la regiºtri. Un
astfel de ºir începe întotdeauna cu simbolul’@’ înaintea ghilimelelor de început.
Exemplu:
using System;
namespace SiruriDeCaractere
{
class Program
{
{
string a = “un sir de caractere”;
string b = “linia unu \nlinia doi”;
string c = @”linia unu
linia doi”;
string d=”c:\\exemple\\unu.cs”;
string e = @”c:\exemple\unu.cs”;
Console.WriteLine(a); Console.WriteLine(b);
Console.WriteLine(c); Console.WriteLine(d);
Console.WriteLine(e); Console.ReadLine();
}
}
}
Programul va avea ieºirea
un sir de caractere
linia unu
linia doi
linia unu
linia doi
c:\exemple\unu.cs
c:\exemple\unu.cs
3.7. Conversii
3.7.1. Conversii numerice
În C# existã douã tipuri de conversii numerice:
• implicite
• explicite.
Conversia implicitã se efectueazã (automat) doar dacã nu este afectatã valoarea
convertitã.
Exemplu:
using System;
using System.Collections.Generic;
using System.Text;
namespace Conversii
{
class Program
{
{
byte a = 13; // byte intreg fara semn
// pe 8 biti
byte b = 20;
long c; //intreg cu semn pe 64 biti
c = a + b;
Console.WriteLine(c);
Console.ReadLine();
}
}
}
Regulile de conversie implicitã sunt descrise de tabelul urmãtor:
din în
sbyte short, int, long, float, double, decimal
byte short, ushort, int, uint, long, ulong, float, double, decimal
short int, long, float, double, decimal
ushort int, uint, long, ulong, float, double, decimal
int long, float, double, decimal
uint long, ulong, float, double, decimal
long float, double, decimal
char ushort, int, uint, long, ulong, float, double, decimal
float double
ulong float, double, decimal
Conversia explicitã se realizeazã prin intermediul unei expresii cast, atunci când nu
existã posibilitatea unei conversii implicite.
Exemplu: în urma rulãrii programului
using System;
using System.Collections.Generic;
using System.Text;
namespace Conversii1
{
class Program
{
{
int a = 5;
int b = 2;
float c;
c = (float)a / b; //operatorul cast
Console.WriteLine(“{0}/{1}={2}”, a, b, c);
Console.ReadLine();
}
}
}
se obþine:
5/2 = 2,5
În cazul în care nu s-ar fi folosit operatorul cast rezultatul, evident eronat, ar fi fost:
5/2=2
Regulile de conversie explicitã sunt descrise de tabelul urmãtor:
din în
sbyte byte, ushort, uint, ulong, char
byte sbyte, char
short sbyte, byte, ushort, uint, ulong, char
ushort sbyte, byte, short, char
int sbyte, byte, short, ushort, uint, ulong, char
uint sbyte,byte, short, ushort, int, char
long sbyte, byte, short, ushort, int, uint, ulong, char
ulong sbyte, byte, short, ushort, int, uint, long, char
char sbyte, byte, short
float sbyte, byte, short, ushort, int, uint, long, ulong, char, decimal
double sbyte, byte, short, ushort, int, uint, long, ulong, char, float, decimal
decimal sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double
3.7.2. Conversii între numere ºi ºiruri de caractere

Limbajul C# oferã posibilitatea efectuãrii de conversii între numere ºi ºiruri de car-
actere.
Sintaxa pentru conversia unui numãr în ºir de caractere:
numãr → ºir “” + numãr
sau se foloseºte metoda ToString a clasei Object.

Pentru conversia inversã, adicã din ºir de caractere în numãr, sintaxa este:
ºir → int int.Parse(ºir) sau Int32.Parse(ºir)

ºir → long long.Parse(ºir sau Int64.Parse(ºir)
ºir → double double.Parse(ºir) sau Double.Parse(ºir)
ºir → float float.Parse(ºir) sau Float.Parse(ºir)
Observaþie: în cazul în care ºirul de caractere nu reprezintã un numãr valid, con-

versia acesui ºir la numãr va eºua.
Exemplu:
using System;
namespace Conversii
{
class Program
{
{
string s;
const int a = 13;
const long b = 100000;
const float c = 2.15F;
double d = 3.1415;
Console.WriteLine(“CONVERSII\n”);
Console.WriteLine(“TIP\tVAL. \tSTRING”);
Console.WriteLine(“———————————”);
s = “” + a;
Console.WriteLine(“int\t{0} \t{1}”,a,s);
s = “” + b;
Console.WriteLine(“long\t{0} \t{1}”,b,s);
s = “” + c;
Console.WriteLine(“float\t{0} \t{1}”,c,s);
s = “” + d;
Console.WriteLine(“double\t{0} \t{1}”,d,s);
Console.WriteLine(“\nSTRING\tVAL \tTIP”);
Console.WriteLine(“———————————”);
int a1;
a1 = int.Parse(“13”);
Console.WriteLine(“{0}\t{1}\tint”,”13”,a1);
long b2;
b2 = long.Parse(“1000”);
Console.WriteLine(“{0}\t{1}\tlong”,”1000”,b2);
float c2;
c2 = float.Parse(“2,15”);
Console.WriteLine(“{0}\t{1}\tfloat”,”2,15”,c2);
double d2;
d2 = double.Parse(“3.1415”,
System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine(“{0}\t{1}\tdouble”,”3.1415”,d2);
Console.ReadLine();
}
}
}
În urma rulãrii se obþine:
CONVERSII
TIP VAL. STRING
———————————
int 13 13
long 100000 100000
float 2,15 2,15
double 3,1415 3,1415
STRING VAL. TIP
———————————
13 13 int
1000 1000 long
2,15 2,15 float
3.1415 3,1415 double
3.7.3. 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 box-
ing a unui tip valoare, care se pãstreazã pe stivã, se produce ambalarea în interiorul
unei instanþe de tip referinþã, care se pãstrazã în memoria heap, la clasa Object.
Unboxing permite convertirea unui obiect într-un tipul valoare corespunzãtor.
Exemplu:
Prin boxing variabila i este asignata unui obiect ob:
int i = 13;
object ob = (object)i; //boxing explicit
sau
int i = 13;
object ob = i; //boxing implicit
Prin conversia de tip unboxing, obiectul ob poate fi asignat variabilei întregi i:

int i=13;
object ob = i; //boxing implicit
i = (int)ob; //unboxing explicit
3.8. Constante
În C# existã douã modalitãþi de declarare a constantelor: folosind const sau
folosind modificatorul readonly. Constantele declarate cu const trebuie sã fie iniþia-
lizate la declararea lor.
Exemple:
const int x; //gresit, constanta nu a fost initializata
const int x = 13; //corect
3.9. Variabile
O variabilã în C# poate sã conþinã fie o valoare a unui tip elementar, fie o referinþã
la un obiect.
Exemple:
int Salut;
int Azi_si _maine;
char caracter;
3.10. Expresii ºi operatori

Prin expresie se înþelege o secvenþã formatã din operatori ºi operanzi. Un opera-
tor este un simbol ce indicã acþiunea care se efectueazã, iar operandul este valoarea
asupra cãreia se executã operaþia. În C# sunt definiþi mai mulþi operatori. În cazul în
care într-o expresie nu intervin paranteze, operaþiile se executã conform prioritãþii
operatorilor. În cazul în care sunt mai mulþi operatori cu aceeaºi prioritate, evaluarea
expresiei se realizeazã de la stânga la dreapta.
Prioritate Tip Operatori Asociativitate

( ) [ ] f() . x++ x-- new typeof sizeof
0 Primar →
checked unchecked ->
1 Unar + - ! ~ ++x --x (tip) true false & sizeof →
2 Multiplicativ * / % →
3 Aditiv + - →
4 De deplasare << >> →
5 Relaþional < > <= >= is as →
6 De egalitate == != →
7 AND (SI) logic & →
8 XOR (SAU exclusiv) logic ^ →
9 OR (SAU) logic | →
10 AND (SI) condiþional && →
11 OR (SAU) condiþional || →
12 Condiþional ?: ←
13 De atribuire = *= /= %= += -= ^= &= <<= >>= |= ←
3.11. Instrucþiuni condiþionale, de iteraþie ºi de control

Ne referim aici la instrucþiunile construite folosind cuvintele cheie: if, else, do,
while, switch, case, default, for, foreach, in, break, continue, goto.
3.11.1 Instrucþiunea if
Instrucþiunea if are sintaxa:
if (conditie)
Instructiuni_A;
else
Instructiuni_B;
Exemplu:
using System;
namespace Test
{
class Program
{
{
int n;
Console.WriteLine(“Introduceti un nr intreg “);
n = Convert.ToInt32(Console.ReadLine());
if (n >= 0)
Console.WriteLine(“Nr. introdus este > 0”);
else
Console.WriteLine(“Nr. introdus este < 0”);
Console.ReadLine();
}
}
}
3.11.2. Instrucþiunea while

Instrucþiunea while are sintaxa:
while (conditie) Instructiuni;
Cât timp conditie este indeplinitã se executã Instructiuni.
Exemplu: Sã se afiºeze numerele întregi pozitive <= 10
using System;
namespace Test
{
class Program
{
{
int n = 0;
while (n <= 10)
{
Console.WriteLine(“n este {0}”, n);
n++;
}
Console.ReadLine();
}
}
}
3.11.3. Instrucþiunea do – while

Instrucþiunea do - while are sintaxa este:
do
Instructiuni;
while(conditie)
Exemplu: Asemãnãtor cu exerciþiul anterior, sã se afiºeze numerele întregi pozitive

<= 10
using System;
namespace Test
{
class Program
{
{
int n = 0;
do
{
n++;
}
while (n <= 10);
Console.ReadLine();
}
}
}
3.11.4. Instrucþiunea for

Instrucþiunea for are sintaxa:
for (initializareCiclu; coditieFinal; pas)

Instructiuni
Exemplu: Ne propunem, la fel ca în exemplele anterioare, sã afiºãm numerele po-

zitive <=10
using System;
namespace Test
{
class Program
{
{
for(int n=0; n<=10; n++)
{
}
Console.ReadLine();
}
}
}
3.11.5. Instrucþiunea switch

La switch în C/C++, dacã la finalul intrucþiunilor dintr-o ramurã case nu existã
break, se trece la urmãtorul case. În C# se semnaleazã eroare. Existã ºi aici posibili-
tatea de a face verificãri multiple (în sensul de a trece la verificarea urmãtoarei
condiþii din case) doar dacã case-ul nu conþine instrucþiuni:
switch (a)
{
case 13:
case 20:
x=5;
y=8;
break;
default:
x=1;
y-0;
break;
}
Instrucþiunea switch admite în C# variabilã de tip ºir de caractere care sã fie com-
paratã cu ºirurile de caractere din case-uri.
Exemplu:
switch(strAnimal)
{
case “Pisica “:
…
break;
case “Catel “:
…
break;
default:
…
break;
}
3.11.6. Instrucþiunea foreach

Instrucþiunea foreach enumerã elementele dintr-o colecþie, executând o instrucþi-
une pentru fiecare element. Elementul care se extrage este de tip read-only,
neputând fi transmis ca parametru ºi nici aplicat un operator care sã-I schimbe va-
loarea. Pentru a vedea cum acþioneazã o vom compara cu instrucþiunea cunoscutã
for. Considerãm un vector nume format din ºiruri de caractere:
string[] nume={“Ana”, Ionel”, “Maria”};
Sã afiºãm acest ºir folosind instrucþiunea for:
for(int i=0; i<nume.Length; i++)

{
Console.Write(“{0} ”, nume[i]);
}
Acelaºi rezultat îl obþinem folosind instrucþiunea foreach:
foreach (string copil in nume)

{
Console.Write(“{0} ”, copil);
}
3.11.7. Instrucþiunea break

Instrucþiunea break permite ieºirea din instrucþiunea cea mai apropiatã switch,
while, do – while, for sau foreach.
3.11.8. Instrucþiunea continue

Instrucþiunea continue permite reluarea iteraþiei celei mai apropiate instrucþiuni
switch, while, do – while, for sau foreach.
Exemplu:
using System;
namespace Salt
{
class Program
{
{
int i = 0;
while(true)
{
Console.Write(“{0} “,i);
i++;
if(i<10)
continue;
else
break;
}
Console.ReadLine();
}
}
}
Se va afiºa:
0 1 2 3 4 5 6 7 8 9
3.11.9. Instrucþiunea goto

Instrucþiunea goto poate fi folositã, în C#, în instrucþiunea switch pentru a face un
salt la un anumit case.
Exemplu:
switch (a)
{
case 13:
x=0;
y=0;
goto case 20;
case 15:
x=3;
y=1;
goto default;
case 20:
x=5;
y=8;
break;
default:
x=1;
y=0;
break;
}
3.12. Instrucþiunile try-catch-finally ºi throw

Prin excepþie se înþelege un obiect care încapsuleazã informaþii despre situaþii
anormale în funcþionarea unui program. Ea se foloseºte pentru a semnala contextul
în care apare o situaþie specialã. De exemplu: erori la deschiderea unor fiºiere,
împãrþire la 0 etc. Aceste erori se pot manipula astfel încât programul sã nu se ter-
mine abrupt.
Sunt situaþii în care prefigurãm apariþia unei erori într-o secvenþã de prelucrare ºi
atunci integrãm secvenþa respectivã în blocul unei instrucþiuni try, precizând una sau
mai multe secvenþe de program pentru tratarea excepþiilor apãrute (blocuri catch) ºi
eventual o secvenþã comunã care se executã dupã terminarea normalã sau dupã
”recuperarea” programului din starea de excepþie (blocul finally).
Exemplu:
using System;
using System.IO;
namespace Exceptii
{
class tryCatch
{
{
Console.Write(“Numele fisierului:”);
string s=Console.ReadLine(s);
try
{
File.OpenRead(s);
}
catch (FileNotFoundException a)
{
Console.WriteLine(a.ToString());
}
catch (PathTooLongException b)
{
Console.WriteLine(b.ToString());
}
finally
{
Console.WriteLine(“Programul s-a sfarsit”);
Console.ReadLine();
}
}
}
}
Alteori putem simula prin program o stare de eroare ”aruncând” o excepþie

(instrucþiunea throw) sau putem profita de mecanismul de tratare a erorilor pentru a
implementa un sistem de validare a datelor prin generarea unei excepþii proprii pe
care, de asemenea, o ”aruncãm” în momentul neîndeplinirii unor condiþii puse
asupra datelor.
Clasa System.Exception ºi derivate ale acesteia servesc la tratarea adecvatã ºi
diversificatã a excepþiilor.
Exemplu: Considerãm clasele Copil, Fetita, Baiat definite fragmentat în capitolul 1.
O posibilitate de validare la adãugara unui copil este aceea care genereazã o excepþie
proprie la depãºirea dimensiunii vectorului static copii:
public static void adaug_copil(Copil c)

{
if (nr_copii < nr_max)
copii[nr_copii++] = c;
else throw new Exception(“Prea mulþi copii”);
}
47
CAPITOLUL 4
Programarea web cu ASP.NET
4.1. Introducere
ASP.NET este tehnologia Microsoft care permite dezvoltarea de aplicaþii web
moderne, utilizând platforma Microsoft .NET cu toate beneficiile sale.
Pentru a înþelege procesul de realizare a unui site web cu ASP.NET este important
sã cunoaºtem modul în care funcþioneazã comunicarea între browser ºi serverul web.
Acest proces este format din urmãtoarele etape principale:
1 Browserul Web iniþiaza o cerere (request) a unei resurse cãtre serverul Web
unde este instalatã aplicaþia doritã.
2 Cererea este trimisã serverului Web folosind protocolul HTTP.
3 Serverul Web proceseazã cererea.
4 Serverul web trimite un rãspuns browserului folosind protocolul HTTP.
5 Browserul proceseazã rãspunsul în format HTML, afiºând pagina web.
6 Utilizatorul poate introduce date (sã spunem într-un formular), apasã butonul
Submit ºi trimite date înapoi cãtre server.
7 Serverul Web proceseazã datele.
8 Se reia de la pasul 4.
Serverul web primeºte cererea (request), iar apoi trimite un rãspuns (response)
înapoi cãtre browser, dupã care conexiunea este închisã, ºi sunt eliberate resursele
folosite pentru procesarea cererii. Acesta este modul de lucru folosit pentru afiºarea
paginilor statice (datele dintr-o paginã nu depind de alte date din alte pagini sau de
alte acþiuni precedente ale utilizatorului) ºi nici o informaþie nu este stocatã pe server.
În cazul paginilor web dinamice, serverul poate sã proceseze cereri de pagini ce
conþin cod care se executã pe server, sau datele pot fi salvate pe server între douã
cereri din partea browserului.
Trimiterea datelor de la browser cãtre server se poate realiza prin metoda GET sau
POST.
Prin GET, URL-ul este completat cu un ºir de caractere (QueryString) format din
perechi de tipul cheie = valoare separate prin &.
Exemplu:
GET /getPerson.aspx?Id=1&city=Cluj HTTP/1.1
Folosind POST, datele sunt plasate în corpul mesajului trimis serverului:

Exemplu:
POST /getCustomer.aspx HTTP/1.1
Id=123&color=blue
Prin Get nu se pot trimite date de dimensiuni mari, iar datoritã faptului cã datele
sunt scrise în URL-ul browser-ului, pot apãrea probleme de securitate. De aceea, de
preferat este sã se foloseascã metoda POST pentru trimiterea de date.
Trimiterea datelor înapoi cãtre server este numitã deseori PostBack. Acþiunea de
PostBack poate fi folositã atât cu metoda GET cât ºi cu metoda POST. Pentru a ºti
dacã se trimit date (POST) sau pagina este doar cerutã de browser (GET), cu alte
cuvinte pentru a ºti dacã pagina curentã se încarcã pentru primã datã sau nu, în
ASP.NET se foloseºte o proprietate a clasei Page numitã IsPostBack.
4.2. Structura unei pagini ASP.NET

La crearea unui proiect nou, în fereastra Solution Explorer apare o nouã paginã
web numitã Default.aspx.
Orice paginã web .aspx este formatã din 3 secþiuni: secþiunea de directive, secþiu-
nea de cod, ºi secþiunea de layout.
Secþiunea de directive se foloseºte pentru a seta mediul de lucru, precizând modul
în care este procesatã pagina.
<%@ Page Language=”C#” AutoEventWireup=”true”

CodeFile=”Default.aspx.cs” Inherits=”_Default” %>
Secþiunea de cod, conþine codul C# asociat paginii sau obiectelor din paginã.
Codul poate fi plasat direct în pagina sau într-un fiºier cu extensia .cs, cu acelaºi
nume ca al paginii (de ex. Default.aspx.cs). În cazul în care se gãseºte direct în pa-
ginã, codul este cuprins între tag-urile <script> </script>:
<script runat=”server”>
protected void Button1_Click(object sender, EventArgs e)
{
Page.Title = “First Web Application”;
}
</script>
De obicei blocurile <script> conþin cod care se executã pe partea de client, însã
dacã se foloseºte atributul runat = „server”, codul se va executa pe serverul web.
În cazul exemplului de mai sus, la apãsarea butonului se schimbã titlul paginii
Web în browser.
CAPITOLUL 4. Programarea web cu ASP.NET 49
În cazul în care în fereastra pentru adãugarea unei pagini noi în proiect, se bifeazã
opþiunea Place code in separate file, codul este plasat într-un fiºier separat, iar în
secþiunea de directive este precizat numele acestui fiºier.
Exemplu: CodeFile=”Default.aspx.cs”.
Secþiunea de layout conþine codul HTML din secþiunea Body:
<body>
<form id=”form1” runat=”server”>
<div>
<asp:Button ID=”Button1” runat=”server” OnClick=”Button1_Click”
Text=”Button” /></div>
</form>
</body>
Atributul runat=”server” pentru un anumit control, specificã faptul cã pentru obiec-

tul respectiv, ASP.NET Runtime Engine care ruleazã pe serverul web (IIS) va face
transformarea într-un obiect HTML standard. Aceastã conversie se realizeazã în
funcþie de tipul browserului, de varianta de javascript instalatã pe browser ºi de codul
C# asociat obiectului respectiv (numit code behind).
De exemplu pagina aspx de mai sus este transformatã în urmãtorul fiºier html:
<form name=”form1” method=”post” action=”Default.aspx” id=”form1”>

<div>
<input type=”hidden” name=”__VIEWSTATE” id=”__VIEWSTATE”
value=”/wEPDwUKMTQ2OTkzNDMyMWRkIftHHP/CS/zQf/D4XczzogN1M1w=” />
</div>
<div> <br />
<input type=”submit” name=”Button1” value=”Button” id=”Button1” style=”z-
index: 102;left: 349px; position: absolute; top: 156px” />
</div>
<div>
<input type=”hidden” name=”__EVENTVALIDATION” = “__EVENTVALIDATION” value =
“/wEWAgKlr8nLBAKM54rGBh7DPY7SctG1t7rMEnJSrO+1hHyP” />
</div>
</form>
Exemple complete de aplicaþii web puteþi gãsi pe DVD-ul Academic Resource Kit (ARK),
instalând Resurse\Visual Studio 2005\101 Samples CS101SamplesAll.msi sau descãrcând
cele 101 exemple de utilizare a Visual Studio 2005 de la adresa http://msdn2.
microsoft.com/en-us/vstudio/aa718334.aspx. Dupã instalare, din aplicaþia Microsoft
Visual Web Developer 2005 alegeþi din meniul File opþiunea Open Web Site ºi selectaþi, din
directorul ..\CS101SamplesAll\CS101SamplesWebDevelopment\, aplicaþia doritã. În fe-
reastra Solution Explorer selectaþi Start.aspx ºi apoi butonul View in Browser".
4.3. Controale Server

Un control server poate fi programat, prin intermediul unui cod server-side, sã
rãspundã la anumite evenimente din paginã. Îºi menþine în mod automat starea între
2 cereri cãtre server, trebuie sã aibã atributul id ºi atributul runat.
Existã douã tipuri de controale server: Web ºi Html. Controalele server web oferã
mai multe funcþionalitãþi programabile decât cele HTML. De asemenea pot detecta
tipul browserului ºi pot fi transformate corespunzãtor în tag-urile html corespunzã-
toare. ASP.NET vine cu o suitã foarte bogatã de controale care pot fi utilizate de cãtre
programatori ºi care acoperã o foarte mare parte din funcþionalitãþile necesare unei
aplicaþii web.
O proprietate importantã a controalelor server este AutoPostBack. Pentru a
înþelege exemplificarea, vom considera o paginã în care avem un obiect de tip check-
box ºi un obiect de tip textbox care are proprietatea visible = false. În momentul în
care este bifat checkbox-ul, vrem ca obiectul textbox sã aparã în paginã. Codul poate
fi urmãtorul:
protected void CheckBox1_CheckedChanged(object sender, EventArgs e)

{
if (CheckBox1.Checked == true)
{
TextBox3.Visible = true;
TextBox3.Focus();
}
else
{
TextBox3.Visible = false;
}
}
Când vom rula pagina, vom constata cã totuºi nu se întâmplã nimic. Pentru a se
executa metoda CheckBox1_CheckedCanged, pagina trebuie retrimisã serverului în
momentul bifãrii checkbox-ului. Serverul trebuie sã execute codul ºi apoi sã retrimitã
cãtre browser pagina în care textbox-ul este vizibil sau nu. De aceea controlul check-
box trebuie sã genereze acþiunea de PostBack, lucru care se întâmplã dacã este setatã
valoarea true proprietãþii AutoPostBack. Unele controale genereazã întotdeauna
Postback atunci când apare un anumit eveniment. De exemplu evenimentul click al
controlului button.
Exemplu de folosire a controalelor web puteþi gãsi pe DVDul ARK, instalând
Resurse\Visual Studio 2005\101 Samples CS101SamplesAll.msi sau descãrcând cele
101 exemple de utilizare a Visual Studio 2005 de la adresa http://msdn2.
microsoft.com/en-us/vstudio/aa718334.aspx, aplicaþia MenuAndSiteMapPath.
Pentru a înþelege mai bine fenomenul de PostBack, ne propunem sã realizãm

urmãtoarea aplicaþie. Într-o paginã avem un textbox ºi un buton. Dorim ca în textbox
sã avem iniþial (la încãrcarea paginii) valoarea 0, ºi de fiecare datã când se apasã
butonul, valoarea din textbox sã fie incrementatã cu 1. Codul evenimentului Click al

butonului ºi al evenimentului Load al paginii ar putea fi urmãtorul:
protected void Page_Load(object sender, EventArgs e)

{
TextBox1.Text = “0”;
}
{
TextBox1.Text = Convert.ToString(Convert.ToInt32(TextBox1.Text) + 1) ;
}
Vom observa, însã, cã dupã prima incrementare valoarea în textbox rãmâne 1.

Acest lucru se întamplã deoarece evenimentul Load se executã la fiecare încãrcare a
paginii (indiferent cã este vorba de request-ul iniþial al browserului sãu de apelul de
postback generat automat de evenimentul clic al butonului). Pentru a remedia
aceastã situaþie, obiectul Page în ASP are proprietarea isPostBack, a.î. putem sã
rescriem codul metodei Load:

{
if (Page.IsPostBack == false) // nu este postback deci e prima
{ // incarcare a paginii
TextBox1.Text = “0”;
}
}
4.4. Pãstrarea informaþiilor în aplicaþiile web

Existã o deosebire fundamentalã între aplicaþiile Windows ºi cele Web. Anume, în
aplicaþiile Windows odatã creat un obiect acesta rãmâne în memorie în principiu
pânã la terminarea aplicaþiei ºi va putea fi utilizat ºi din alte ferestre decât cele în care
a fost creat, atâta timp cât este public. Pe de altã parte, în aplicaþiile web paginile nu
se pãstreazã în memorie pe calculatorul utilizatorului (clientului) iar aici ne vom pune
problema pãstrãrii informaþiilor.
Când browserul cere o anumitã paginã, ea este încãrcatã de serverul web, se exe-
cutã codul asociat pe baza datelor trimise de user, rezultând un rãspuns în format
html trimis browserului. Dupã ce este prelucratã pagina de cãtre server, obiectele din
paginã sunt ºterse din memorie, pierzând astfel valorile. De aceea apare întrebarea:
cum se salveazã/transmit informaþiile între paginile unui site web sau chiar în cadrul
aceleiaºi pagini, între douã cereri succesive cãtre server?
4.4.1. Pãstrarea stãrii controalelor

Obiectul ViewState
Starea controalelor unei pagini este pastratã automat de cãtre ASP.NET ºi astfel
nu trebuie sã ne facem griji cu privire la informaþiile care apar în controale pentru ca
ele nu vor dispãrea la urmãtorul PostBack – adicã la urmãtoarea încãrcare a paginii

curente. De exemplu, dacã scriem un text într-o cãsuþã de text ºi apoi apãsãm un
buton care genereazã un PostBack iar pagina se reîncarcã, ea va conþine cãsuþa de
text respectivã cu textul introdus de noi înainte de reîncãrcare.
În momentul generãrii codului Html de cãtre server se genereazã un control html
de tip <input type=”hidden”...> , a cãrui valoare este un ºir de caractere ce codificã
starea controalelor din paginã:
<input type=”hidden” name=”__VIEWSTATE” id=”__VIEWSTATE”

value=”/wEPDwULLTE1OTg1NDYyNDZkZFCFstl/DwSGv81TuCB397Tk5+CJ” />
Se pot adãuga valori în ViewState ºi de cãtre programator, folosind obiectul

ViewState cu metoda Add (cheie, valoare_obiect): ViewState.Add(“TestVariable”,
“Hello”);

{
if (Page.IsPostBack == false)
{
ViewState.Add(“ViewStateTest”, “Hello”);
}
}
Regãsirea datelor se realizeazã folosind ca indice numele obiectului:

{
TextBox1.Text = ViewState[“ViewStateTest”].ToString();
}
4.4.2. Pãstrarea altor informaþii

Aºa cum am observat în paragraful anterior, starea controalelor de pe o anumitã
paginã web ASP.NET se pastreazã între mai multe cereri cãtre server pentru aceeaºi
paginã, folosind obiectul ViewState în mod automat, transparent pentru programator.
Dacã dorim sã pãstrãm mai multe informaþii decât doar conþinutul controalelor,
cum ar fi valorile unor variabile instanþiate într-o anumitã paginã, atunci va trebui sã
o facem explicit, pentru cã acestea se pierd în momentul în care serverul web
regenereazã pagina curentã, ceea ce se întâmplã la fiecare PostBack , cum se întâm-
plã de exemplu la apãsarea unui buton ASP.NET.
4.4.2.1. Profile
O posibilitate de pãstrare a informaþiilor specifice unui utilizator constã în folosirea

obiectului Profile, prin intermediul fiºierului de configurare Web.Config. Acesta este
un fiºier XML în care se reþin opþiuni de configurare. Pentru a adãuga o proprietate
obiectului profile, în fiºierul Web.Config se adaugã:
<profile enabled=”true”>
<properties>
<add name =”ProfileTest” allowAnonymous =”true”/>
</properties>
</profile>
Atributul name reþine numele proprietãþii. Dupã aceste modificãri, proprietatea

definitã în Web.config poate fi apelatã pentru obiectul Profile:
Profile.ProfileTest = “Hello world”;

Sau
Label1.Text = Profile.ProfileTest;
4.4.2.2. Session
Obiectul Session este creat pe serverul web la prima accesare a sitului de cãtre un
utilizator ºi rãmâne în memorie în principiu atât timp cât utilizatorul rãmâne conectat
la site. Existã ºi excepþii, dar ele nu fac obiectul acestui material.
Pentru a adãuga un obiect în sesiune, trebuie doar sã scriem un cod de genul
urmãtor:

{
Session[“sir”] = test;
}
Session este de fapt un dicþionar (listã de perechi cheie – valoare), în care valo-
rile sunt de tip object. Ceea ce înseamnã cã la citirea unor valori din sesiune va tre-
bui sã realizãm o conversie de tip.

{
test = Session[“sir”].ToString();
TextBox1.Text = test;
}
Odatã introdus un obiect în Session, el poate fi accesat din toate paginile aplicaþiei,
atât timp cât el existã acolo. Programatorul poate realiza scoaterea obiectului din
sesiune atunci când doreºte acest lucru:
Session.Remove(“sir”);
4.4.2.3. Application
Obiectul Application se comportã în mod identic cu Session, doar cã este specific

întregii aplicaþii, adicã tuturor utilizatorilor care acceseaza un site web la un moment
dat, ºi nu unei anumite sesiuni. Cu alte cuvinte odatã introdus un obiect în Applicatio,
va putea fi accesat din orice loc al sitului ºi de cãtre toþi utilizatorii acestuia.
4.4.2.4. Membrii statici
Toate variabilele declarate ca fiind statice sunt specifice întregii aplicaþii ºi nu unei
anumite sesiuni. De exemplu, dacã atunci când un site este accesat de Utilizator1 ºi
o variabilã declaratã:
static string test = “init”;
se modificã de cãtre acesta:
test = “modificat”;
atunci toþi utilizatorii aplicaþiei vor vedea valoarea modificatã din acel moment
înainte.
4.4.3. Concluzii
În cazul obiectului ViewState, datele sunt salvate în pagina web sub forma unui ºir
de caractere, iar în cazul obiectului Session respectiv Application în memoria
serverului web. Dacã datele salvate sunt de dimensiuni mari, în primul caz creºte
dimensiunea paginii web, care va fi transmisã mai încet, iar în al doilea caz rezultã o
folosire excesivã a memoriei serverului web, ceea ce duce la scãderea vitezei de
lucru. Aceastã folosire excesivã a memoriei poate sã aparã ºi în cazul unei dimen-
siuni a datelor ceva mai redusã, dar a unui numãr mare de utilizatori care acceseazã
simultan pagina (pentru fiecare se va creea un obiect sesiune).
4.5. Validarea datelor

În toate aplicaþiile web ºi nu numai se pune problema validãrii datelor introduse
de utilizator. Cu alte cuvinte, trebuie sã ne asigurãm cã utilizatorul site-ului nostru
introduce numai date corecte în cãsuþele de text care îi sunt puse la dispoziþie. De
exemplu, dacã pe o paginã web se cere utilizatorului introducerea vârstei sale ºi pen-
tru asta îi punem la dispozitie o cãsuþã de text, va fi obligatoriu sã ne asigurãm cã în
acea cãsuþã se pot introduce numai cifre ºi cã numãrul rezultat este încadrat într-un
anumit interval. Sau, un alt exemplu, este introducerea unei adrese de email validã
din punct de vedere al formatului.
ASP.NET vine cu o serie de controale gata create în scopul validãrii datelor. Aceste
controale sunt de fapt clase care provin din aceeaºi ierarhie, având la bazã o clasã cu
proprietãþi comune tuturor validatoarelor.
4.5.1. Proprietãþi comune

1 ControlToValidate: este proprietatea unui control de validare care aratã spre
controlul (cãsuþa de text) care trebuie sã fie validat.
2 ErrorMessage: reprezintã textul care este afiºat în pagina atunci când datele din
controlul de validat nu corespund regulii alese.

3 EnableClientSideScript: este o proprietate booleanã care specificã locul în care
se executã codul de validare (pe client sau pe server).
4 Alte proprietãþi, specifice tipului de validator.
4.5.2. Validatoare
1 RequiredFieldValidator. Verificã dacã în cãsuþa de text asociatã prin proprietatea
ControlToValidate s-a introdus text. Util pentru formularele în care anumite date
sunt obligatorii.
2 RangeValidator. Verificã dacã informaþia introdusã în cãsuþa de text asociatã
face parte dintr-un anumit interval, specificat prin tipul datei introduse (prorie-
tatea Type) ºi MinimumValue respectiv MaximumValue.
3 RegularExpressionValidator. Verificã dacã informaþia din cãsuþa de text asociatã
este conform unei expresii regulate specificate. Este util pentru validarea unor
informaþii de genul adreselor de email, numerelor de telefon, etc – în general
informaþii care trebuie sã respecte un anumit format. Trebuie setatã proprietatea
ValidationExpression în care se pot alege câteva expresii uzuale gata definite.
4 CompareValidator. Comparã datele introduse în cãsuþa de text asociatã cu o va-
loare prestabilitã (ValueToCompare), în funcþie de operatorul ales (proprietatea
Operator) ºi de tipul de date care se aºteaptã (proprietatea Type).
Pe lângã validatoarele prezentate mai sus, programatorul poate crea validatoare

customizate, care sã verifice datele introduse de utilizator conform unor reguli proprii.
Exemplu de folosire a validãrilor pentru un modul de login puteþi gãsi pe dvd-ul
ARK, instalând Resurse\Visual Studio 2005\101 Samples CS101SamplesAll.msi sau
descãrcând cele 101 exemple de utilizare a Visual Studio 2005 de la adresa
http://msdn2.microsoft.com/en-us/vstudio/aa718334.aspx, aplicaþia Membership.
4.6. Securitatea în ASP.NET

Pentru o aplicaþie securizatã, avem mai multe posibilitãþi de autentificare, cele mai
des întâlnite fiind sintetizate în tabelul de pe slide. Implementarea politicii de securi-
tate se poate face atât din IIS cât ºi din aplicaþia ASP.NET.
Tipul aplicaþiei Modul de autentificare Descriere

Aplicaþie web publicã
Anonim Nu avem nevoie de securizare.
pe Internet.
Acest mod autentificã utilizatorii folosind lista de useri
Aplicaþie web pentru de pe server (Domain Controller). Drepturile userilor în
Windows Integrated
Intranet. aplicaþia web este dat de nivelul de privilegii al contu-
lui respectiv.
Aplicaþie web disponi- Utilizatorii companiei pot accesa aplicaþia din afara
bilã pe Internet, dar Windows Integrated Intranetului, folosind conturi din lista serverului
cu acces privat. (Domain Controller).
Aplicaþii web Aplicaþii care au nevoie de informaþii confidenþiale ºi

Forms Authentication
comerciale. eventual în care sunt mai multe tipuri de utilizatori.
4.6.1. Windows Authentication

În acest mod de autentificare, aplicaþia 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 aplicaþia Web.
2. Cererea ajunge la Serverul Web IIS care comparã datele de autentificare ale uti-
lizatorului cu cele ale aplicaþiei (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 cãtre IIS
6. IIS verificã datele de autentificare, ºi în cazul în care sunt corecte, direcþioneazã
cererea cãtre aplicaþia Web.
7. Pagina securizatã este returnatã utilizatorului.
4.6.2. Forms-Based Authentication

Atunci când se utilizeazã autentificarea bazatã pe formulare, IIS nu realizeazã au-
tentificarea, deci este necesar ca în setãrile 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 cãtre ASP.NET
2. Acesta verificã pe calculatorul clientului prezenþa unui anumit cookie1
3. Dacã cookie-ul nu este prezent sau este invalid, ASP.NET refuzã cererea clientu-
lui ºi returneazã o paginã de autentificare (Login.aspx)
4. Clientul completeazã informaþiile cerute în pagina de autentificare ºi apoi trimite
informaþiile
5. Din nou, IIS autentificã clientul ca fiind un utilizator anonim ºi trimite cererea
cãtre ASP.NET
6. ASP.NET autentificã clientul pe baza informaþiilor furnizate. De asemenea
genereazã ºi un cookie. Cookie reprezintã un mic fiºier text ce pãstreazã diverse
informaþii despre utilizatorul respectiv, informaþii folosite la urmãtoarea vizitã a
sa pe site-ul respectiv, la autentificare, sau în diverse alte scopuri.
7. Pagina securizatã cerutã ºi noul cookie sunt returnate clientului. Atâta timp cât
acest cookie rãmâne valid, clientul poate solicita ºi vizualiza orice paginã secu-
rizatã ce utilizeazã aceleaºi informaþii de autentificare.
4.6.3. Securizarea unei aplicaþii web

Securizarea unei aplicaþii web presupune realizarea a douã obiective: (1) autentifi-
carea ºi (2) autorizarea.
1. Autentificarea presupune introducerea de cãtre utilizator a unor credenþiale, de

exemplu nume de utilizator ºi parolã, iar apoi verificarea în sistem cã acestea
existã si sunt valide.
2. Autorizarea este procesul prin care un utilizator autentificat primeºte acces pe

resursele pe care are dreptul sã le acceseze.
Aceste obiective pot fi atinse foarte uºor utilizând funcþionalitãþile ºi uneltele din
ASP.NET respectiv Visual Studio, anume clasa Membership ºi unealta
ASP.NET Configuration (din meniul Website al Visual Studio Web Developer
Express). Configurarea autentificãrii ºi autorizãrii se poate realiza dupã cum se vede
în acest tutorial:
http://msdn2.microsoft.com/en-us/library/879kf95c(VS.80).aspx.
Un exemplu de securizare a aplicaþilor web puteþi gãsi pe dvd-ul ARK, instalând
Resurse\Visual Studio 2005\101 Samples CS101SamplesAll.msi sau descãrcând cele
101 exemple de utilizare a Visual Studio 2005 de la adresa http://msdn2.
microsoft.com/en-us/vstudio/aa718334.aspx, aplicatia Security.
4.7. Accesul la o baza de date într-o paginã web

Pentru adãugarea unei baze de date proiect, din meniul Add Item se alege SQL
Database. Baza de date va fi adaugatã în directorul App_data al proiectului.
Legãtura între baza de date ºi controalele html se realizeazã prin intermediul
obiectului SqlDataSource. Din meniul contextual asociat acestui obiect se alege op-
þiunea Configure Data Source, se alege baza de date, ºi se construieºte interogarea
SQL pentru regãsirea datelor.
La aceastã sursã de date se pot lega controale de afiºare a datelor cum ar fi:
GridView, Detailview, FormView. Din meniul contextual asociat acestor controale se
alege opþiunea Choose data source, de unde se alege sursa de date.
Un exemplu de acces la o bazã de date într-o aplicaþie web puteþi gãsi pe DVD-ul
ARK instalând Resurse\Visual Studio 2005\101 Samples CS101SamplesAll.msi sau
descãrcând cele 101 exemple de utilizare a Visual Studio 2005 de la adresa
http://msdn2.microsoft.com/en-us/vstudio/aa718334.aspx, aplicaþia DataControls.
Pentru acest exemplu va trebui sã descãrcaþi baza de date AdventureWorksDB de la
adresa http://www.codeplex.com/MSFTDBProdSamples/Release/ProjectReleases.
aspx?ReleaseId=4004. Fiºierul descãrcat va fi unul de tip *.msi care trebuie lansat
pentru a instala baza de date pe server/calculator.
4.8. Resurse
Dezvoltarea de aplicaþii web cu Visual Web Developer Express:
http://msdn.microsoft.com/vstudio/express/vwd/
59
CAPITOLUL 5
Programare vizualã
5.1. Concepte de bazã ale programãrii vizuale

Programarea vizualã trebuie privitã ca un mod de proiectare a unui program prin
operare directã asupra unui set de elemente grafice (de aici vine denumirea de pro-
gramare vizualã). Aceastã operare are ca efect scrierea automatã a unor secvenþe de
program, secvenþe care, împreunã cu secvenþele scrise textual28, vor forma progra-
mul.
Spunem cã o aplicaþie este vizualã dacã dispune de o interfaþã graficã sugestivã ºi
pune la dispoziþia utilizatorului instrumente specifice de utilizare (drag, clic, hint etc.)
Realizarea unei aplicaþii vizuale nu constã doar în desenare ºi aranjare de con-
troale, ci presupune în principal stabilirea unor decizii arhitecturale29, 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
aplicaþii este foarte mic, o parte a codului este generatã automat de Visual
Stdio.Net, codul nu este foarte uºor de întreþinut ºi este recomandat pentru apli-
caþii relativ mici sau cu multe operaþii de acces (in/out) la o bazã de date.
b)Modelul arhitectural Model-view-controller
Este caracterizat de cele trei concepte de bazã: Model (reprezentarea datelor se
realizeazã într-o manierã specificã aplicaþiei: conþine obiectele de „business”,
încapsuleazã accesul la date), View (sunt utilizate elemente de interfaþã, este
format din Form-uri), Controller( proceseazã ºi rãspunde la evenimente iar SO,
clasele Form ºi Control din .Net ruteazã evenimentul cãtre un „handler”, eveni-
ment tratat în codul din spatele Form-urilor).
c) Modelul arhitectural Multi-nivel
Nivelul de prezentare ( interfaþa)
Se ocupã numai de afiºarea informaþiilor cãtre utilizator ºi captarea celor introduse de
acesta. Nu cuprinde detalii despre logica aplicaþiei, ºi cu atât mai mult despre baza de date
28 Se utilizeazã ades antonimia dintre vizual (operaþii asupra unor componente grafice) ºi textual (scriere de linii de
cod); proiectarea oricãrei aplicaþii "vizuale" îmbinã ambele tehnici.
29 Deciziile arhitecturale stabilesc în principal cum se leagã interfaþa de restul aplicaþiei ºi cât de uºor de întreþinut
este codul rezultat.
sau fiºierele pe care aceasta le utilizeazã. Cu alte cuvinte, în cadrul interfeþei cu utilizatorul,
nu se vor folosi obiecte de tipuri definite de programator, ci numai baza din .NET.
Nivelul de logicã a aplicaþiei
Se ocupã de tot ceea ce este specific aplicaþiei care se dezvoltã. Aici se efectueazã
calculele ºi procesãrile ºi se lucreazã cu obiecte de tipuri definite de programator.
Nivelul de acces la date
Aici rezidã codul care se ocupã cu accesul la baza de date, la fiºiere, la alte servicii.
Aceastã ultimã structurã este foarte bunã pentru a organiza aplicaþiile, dar nu este
uºor de realizat. De exemplu, dacã în interfaþa cu utilizatorul prezentãm date sub
formã ListView ºi la un moment dat clientul ne cere reprezentarea datelor într-un
GridView, modificãrile la nivel de cod nu se pot localiza doar în interfaþã deoarece
cele douã controale au nevoie de modele de acces la date total diferite.
Indiferent de modelul arhitectural ales, în realizarea aplicaþiei mai trebuie respec-
tate ºi principiile proiectãrii interfeþelor:
Simplitatea
Interfaþa trebuie sã fie cât mai uºor de înþeles30 ºi de învãþat de cãtre utilizator ºi
sã permitã acestuia sã efectueze operaþiile dorite în timp cât mai scurt. În acest sens,
este vitalã culegerea de informaþii despre utilizatorii finali ai aplicaþiei ºi a modului în
care aceºtia sunt obiºnuiþi sã lucreze.
Poziþia controalelor
Locaþia controalelor dintr-o fereastrã trebuie sã reflecte importanþa relativã ºi
frecvenþa de utilizare. Astfel, când un utilizator trebuie sã introducã niºte informaþii –
unele obligatorii ºi altele opþionale – este indicat sã organizãm controalele astfel
încât primele sã fie cele care preiau informaþii obligatorii.
Consistenþa
Ferestrele ºi controalele trebuie sã fie afiºate dupã un design asemãnãtor („tem-
30 Întrucât mintea umanã poate sã perceapã la un moment dat aproximativ 5-9 obiecte, o fereastrã supra-încãrcatã
de controale o face greu de utilizat..
CAPITOLUL 5. Programare vizualã 61
plate”) pe parcursul utilizãrii aplicaþiei. Înainte de a implementa interfaþa, trebuie

decidem cum va arãta aceasta, sã definim „template”-ul.
Estetica
Intefaþa trebuie sã fie pe cât posibil plãcutã ºi atrãgãtoare.
5.2. Mediul de dezvoltare Visual C#

Mediul de dezvoltare Microsoft Visual C# dispune de instrumente specializate de
proiectare, ceea ce permite crearea aplicaþiilor în mod interactiv, rapid ºi uºor.
Pentru a construi o aplicaþie Windows (FileÆNew Project) se selecteazã ca tem-
plate Windows Application.
O aplicaþie Windows conþine cel puþin o fereastrã (Form) în care se poate crea o
interfaþã cu utilizatorul aplicaþiei.
Componentele vizuale ale aplicaþiei pot fi prelucrate în modul Designer (Shift+F7)
pentru a plasa noi obiecte, a le stabili proprietãþile etc. Codul ”din spatele” unei com-
ponente vizuale este accesibil în modul Code (F7).
În fereastra Solution Explorer sunt afiºate toate fiºierele pe care Visual Studio.NET
le-a inclus în proiect. Form1.cs este formularul creat implicit de Visual Studio.NET ca
parte a proiectului.
Fereastra Properties este utilizatã pentru a schimba proprietãþile obiectelor.
Toolbox conþine controale standard drag-and-drop ºi componente utilizate în
crearea aplicaþiei Windows. Controalele sunt grupate în categoriile logice din ima-
ginea alãturatã.
Designer, Code, Solution Explorer ºi celelalte se aflã grupate în meniul View.

La crearea unei noi aplicaþii vizuale, Visual Studio.NET genereazã un spaþiu de
nume ce conþine clasa staticã Program, cu metoda staticã ce constituie punctul de
intrare (de lansare) a aplicaþiei:
static void Main()

{ ...
Application.Run(new Form1());
}
Clasa Application este responsabilã cu administrarea unei aplicaþii Windows,

punând la dispoziþie proprietãþi pentru a obþine informaþii despre aplicaþie, metode
de lucru cu aplicaþia ºi altele. Toate metodele ºi proprietãþile clasei Application sunt
statice. Metoda Run invocatã mai sus creeazã un formular implicit, aplicaþia rãspun-
zând la mesajele utilizatorului pânã când formularul va fi închis.
Compilarea modulelor aplicaþiei ºi asamblarea lor într-un singur fiºier ”exe-
cutabil” se realizeazã cu ajutorul opþiunilor din meniul Build, uzualã fiind Build
Solution (F6).
Odatã implementatã, aplicaþia poate fi lansatã, cu asistenþã de depanare sau nu
(opþiunile Start din meniul Debug). Alte facilitãþi de depanare pot fi folosite prin
umãrirea pas cu pas, urmãrirea pânã la puncte de întrerupere etc. (celelalte opþiuni ale
meniului Debug). Ferestre auxiliare de urmãrire sunt vizualizate automat în timpul pro-
cesului de depanare, sau pot fi activate din submeniul Windows al meniului Debug.
5.3. Ferestre
Spaþiul 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 mãsurã
ce noi desemnãm componentele ºi comportamentul acesteia. În fapt, acest cod rea-
lizeazã: derivarea unei clase proprii din System.Windows.Forms.Form, clasã care
este înzestratã cu o colecþie de controale (iniþial vidã). Constructorul ferestrei rea-
lizeazã instanþieri ale claselor Button, MenuStrip, Timer etc. (orice plasãm noi în fer-
eastrã) ºi adaugã referinþele acestor obiecte la colecþia de controale ale ferestrei.
Dacã modelul de fereastrã reprezintã ferestra principalã a aplicaþiei, atunci ea este
instanþiatã automat în programul principal (metoda Main). Dacã nu, trebuie sã scriem
noi codul ce realizeazã instanþierea.
Clasele derivate din Form moºtenesc o serie de proprietãþi care determinã
atributele vizuale ale ferestrei (stilul marginilor, culoare de fundal, etc.), metode care
implementeazã anumite comportamente (Show, Hide, Focus etc.) ºi o serie de
metode specifice (handlere) de tratare a evenimentelor (Load, Clic etc.).
O fereastrã poate fi activatã cu form.Show() sau cu form.ShowDialog(), metoda a
doua permiþând ca revenirea în fereastra din care a fost 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 deþinut.
Activarea propietarului unui formular deschis modal va determina activarea formula-
rului deschis modal. Când un nou formular este activat folosind form.Show() nu va
avea nici un deþinãtor, acesta stabilindu-se direct:
public Form Owner { get; set; }

F_nou form=new F_nou();
form.Owner = this; form.Show();
Formularul deschis modal va avea un proprietar setat pe null. Deþinãtorul se poate

stabili setând proprietarul înainte sã apelãm Form.ShowDialog() sau apelând
From.ShowDialog() cu proprietarul ca argument.

F_nou form = new F_nou();form.ShowDialog(this);
Vizibilitatea unui formular poate fi setatã folosind metodele Hide sau Show. Pentru a
ascunde un formular putem folosi:
this.Hide(); // setarea propietatii Visible indirect sau

this.Visible = false; // setarea propietatii Visible direct
Printre cele mai uzuale proprietãþi ale form-urilor, reamintim:

• StartPosition determinã poziþia ferestrei atunci când aceasta apare prima datã,
poziþie ce poate fi setatã Manual sau poate fi centratã pe desktop
(CenterScreen), stabilitã de Windows, formularul având dimensiunile ºi locaþia
stabilite de programator (WindowsDefaultLocation) sau Windows-ul va stabili
dimensiunea iniþialã ºi locaþia pentru formular (WindowsDefaultBounds) sau,
centrat pe formularul care l-a afiºat (CenterParent) atunci când formularul va fi
afiºat modal.
• Location (X,Y) reprezintã coordonatele colþului din stânga sus al formularului
relativ la colþul stânga sus al containerului. (Aceastã propietate e ignoratã dacã
StartPosition = Manual). Miºcarea formularului ( ºi implicit schimbarea locaþiei)
poate fi tratatã în evenimentele Move ºi LocationChanged .
Locaþia formularului poate fi stabilitã relativ la 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. Când se schimbã pro-

prietãþile 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 întregu-
lui conþinut al sãu. 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 restricþiona dimensiunile
unui formular.
void Form_Load(object sender, EventArgs e) {

this.MinimumSize = new Size(200, 100);...
this.MaximumSize = new Size(int.MaxValue, 100);...}
• IsMdiContainer precizeazã dacã form-ul reprezintã un container pentru alte

form-uri.
• ControlBox precizeazã dacã fereastra conþine sau nu un icon, butonul de închidere
al ferestrei ºi meniul System (Restore, Move, Size, Maximize, Minimize, Close).

• HelpButton-precizeazã dacã butonul va apãrea sau nu lângã butonul de
închidere al formularului (doar dacã MaximizeBox=false, MinimizeBox=false).
Dacã utilizatorul apasã acest buton ºi apoi apasã oriunde pe formular va apãrea
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 opacitate31
• ShowInTaskbar precizeazã dacã fereastra apare in TaskBar atunci când formula-
rul este minimizat.
• SizeGripStyle specificã tipul pentru ‘Size Grip’ (Auto, Show, Hide). Size grip
(în colþul din dreapta jos) indicã faptul cã aceastã fereastrã poate fi redimensionatã.
• TopMost precizeazã dacã fereastra este afisatã în faþa tuturor celorlalte ferestre.
• TransparencyKey identificã o culoare care va deveni transparentã pe formã.
Definirea unei funcþii de tratare a unui eveniment asociat controlului se realizeazã

prin selectarea grupului Events din ferestra Properties a controlului respectiv ºi
alegerea evenimentului dorit.
Dacã nu scriem nici un nume pentru funcþia de tratare, ci efectuãm dublu clic în
cãsuþa respectivã, se genereazã automat un nume pentru aceastã funcþie, þinând cont
de numele controlului ºi de numele evenimentului (de exemplu button1_Click).
Dacã în Designer efectuãm dublu clic pe un control, se va genera automat o funcþie
de tratare pentru evenimentul implicit asociat controlului (pentru un buton eveni-
mentul implicit este Click, pentru TextBox este TextChanged, pentru un formular
Load etc.).
Printre evenimentele cele mai des utilizate, se numãrã :
• Load apare când formularul este pentru prima data încãrcat în memorie.
• FormClosed apare când formularul este închis.
• FormClosing apare când formularul se va inchide ca rezultat al acþiunii utiliza-
torului asupra butonului Close (Dacã se seteazã CancelEventArgs.Cancel =True
atunci se va opri închiderea formularului).
• Activated apare pentru formularul activ.
• Deactivate apare atunci când utilizatorul va da clic pe alt formular al aplicatiei.
5.4. Controale
Unitatea de bazã a unei interfeþe Windows o reprezintã un control. Acesta poate fi
„gãzduit” 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 pãrþi din container. Visual Studio .NET vine cu o serie
de controale standard, disponibile în Toolbox. Aceste controale pot fi grupate astfel:
31 Dacã va fi setatã la 10% formularul ºi toate controalele sale vor fi aproape invizibile.
5.4.1. Controale form. Controlul form este un container. Scopul sãu este de a gãzdui
alte controale. Folosind proprietãþile, metodele ºi evenimentele unui formular,
putem personaliza programul nostru.
În tabelul de mai jos veþi gãsi o listã cu controalele cel mai des folosite ºi cu
descrierea lor. Exemple de folosire a acestor controale vor urma dupã explicarea pro-
prietãþilor comune al controalelor ºi formularelor.
Funcþia controlului Numele controlului Descriere

Sunt folosite pentru a executa o secvenþã de instrucþiuni în
buton Button
momentul activãrii lor de cãtre utilizator
Afiºeazã implicit un mic calendar al lunii curente. Acesta
calendar MonthCalendar poate fi derulat ºi înainte ºi înapoi la celelalte luni calen-
daristice.
casetã de validare CheckBox Oferã utilizatorului opþiunile : da/nu sau include/exclude
Sunt folosite pentru afiºarea etichetelor de text, ºi a pentru
etichetã Label
a eticheta controalele.
casetã cu listã ListBox Afiºeazã o listã de articole din care utilizatorul poate alege.
Este folosit pentru adãugarea imaginilor sau a altor resurse
imagine PictureBox
de tip bitmap.
Este utilizat pentru selectarea, mutarea sau redimension-
pointer Pointer
area unui control.
Este folosit pentru ca utilizatorul sã selecteze un singur ele-
buton radio RadioButton
ment dint-un grup de selecþii.
Este utilizat pentru afiºarea textului generat de o aplicaþie
casetã de text TextBox sau pentru a primi datele introduse de la tastaturã de cãtre
utilizator.
5.4.2. Proprietãþi comune ale controalelor ºi formularelor:

Proprietatea Text Aceastã proprietate poate fi setatã în timpul proiectãrii din fereas-
tra Properties, sau programatic, introducând o declaraþie în codul programului.
Exemplu:
public Form1()
{
InitializeComponent();
this.Text = “Primul formular”;
}
Proprietãþile ForeColor ºi BackColor. Prima proprietate enunþatã seteazã culoare tex-

tului din formular, iar cea de a doua seteazã culoarea formularului. Toate acestea le
puteþi modifica dupã preferinþe din fereastra Properties.
Proprietatea BorderStyle. Controleazã stilul bordurii unui formular. Încercaþi sã

vedeþi cum se modificã setând proprietatea la Fixed3D. (tot din fereastra Properties)
Proprietatea FormatString vã permite sã setaþi un format comun de afiºare pentru
toate obiectele din cadrul unei ListBox. Aceasta se gãseºte disponibilã în panoul
Properties.
Proprietatea Multiline schimbã setarea implicitã a controlului TextBox de la o singurã
linie, la mai multe linii. Pentru a realiza acest lucru trageþi un TextBox într-un formular
ºi modificaþi valoarea proprietãþii Multiline din panoul Properties de la False la true.
Proprietatea AutoCheck când are valoarea true, un buton radio îºi va schimba starea
automat la executarea unui clic.
Proprietatea AutoSize folositã la controalele Label ºi Picture, decide dacã un control
este redimensionat automat, pentru a-i cuprinde întreg conþinutul.
Proprietatea Enabled determinã dacã un control este sau nu activat într-un formular.
Proprietatea Font determinã fontul folosit într-un formular sau control.
Proprietatea ImageAlign specificã alinierea unei imagini aºezate pe suprafaþa con-
trolului.
Proprietatea TabIndex seteazã sau returneazã poziþia controlului în cadrul aranjãrii
taburilor.
Proprietatea Visible seteazã vizibilitatea controlului.
Proprietatea Width and Height permite setarea înãlþimii ºi a lãþimii controlului.
5.4.3. Câteva dintre metodele ºi evenimentele Form

Când dezvoltãm programe pentru Windows, uneori trebuie sã afiºãm ferestre
adiþionale. De asemenea trebuie sã le facem sã disparã de pe ecran. Pentru a reuºi
acest lucru folosim metodele Show() ºi Close() ale controlului. Cel mai important
eveniment pentru Button este Click (desemnând acþiunea clic stânga pe buton).
Un exemplu în acest sens:
Deschideþi o nouã aplicaþie Windows. Trageþi un buton pe formular. Din meniul
Project selectaþi Add Windows Form, iar în caseta de dialog care apare adãugaþi
numele Form2, pentru noul formular creat. În acest moment aþi inclus în program
douã formulare. Trageþi un buton în Form2 ºi executaþi dublu clic pe buton, pentru a
afiºa administratorul sãu de evenimente. Introduceþi acum în el linia de cod
this.Close();.
private void button1_Click(object sender, EventArgs e)
{
this.Close();
}
Numele metodei button1_Click este alcãtuit din numele controlului button1,

urmat de numele evenimentului: Click.
Acum ar trebui sã reveniþi la Form1 ºi executaþi dublu clic pe butonul din acest for-
mular pentru a ajunge la administratorul sãu de evenimente. Editaþi administratorul
evenimentului conform exemplului de mai jos:

{
Form2 form2 = new Form2();
form2.Show();
}
În acest moment rulaþi programul apãsând tasta F5 ºi veþi observa cã la executarea

unui clic pe butonul din Form1 se deschide Form2 iar la executarea unui clic pe
butonul din Form2 acesta se închide.
Tot în cadrul evenimentului Click, oferim acum un exemplu de afiºare într-un

TextBox a unui mesaj, în momentul în care se executã clic pe un buton:
Deschideþi o nouã aplicaþie Windows. Trageþi un buton pe formular ºi o casetã

TextBox. Modificaþi textul ce apare pe buton, conform imaginii, ºi executaþi dublu clic
pe el, pentru a ajunge la administratorul sãu de evenimente. Modificaþi sursa astfel
încât sã arate în modul urmãtor.

{
string a = “PLATFORMA .NET”;
textBox1.Text = a;
}
Casete de mesaje:
Pentru a crea o casetã mesaj, apelãm metoda MessageBox.Show();.Într-o nouã apli-
caþie Windows, trageþi un buton în formular, modificaþi textul butonului cum doriþi
sau ca în imaginea alãturatã „va apare un mesaj”, executaþi dublu clic pe buton ºi
adãugaþi în administratorul evenimentului Click linia de program: MessageBox.Show(“ti-

am spus”);. Apoi rulaþi programul.
Casete de dialog
O casetã de dialog este o formã specializatã de control de tip Form.
Exemplu:
Creaþi o nouã aplicaþie Windows, apoi trageþi un buton în formular ºi setaþi propri-
etatea Text a butonului la : „sã avem un dialog”, iar apoi executaþi dublu clic pe buton
ºi folosiþi urmãtorul cod pentru administratorul evenimentului Click.

{
Form2 w = new Form2();
w.ShowDialog();
}
Creaþi un alt formular la acest proiect(alegeþi Add Windows Forms din meniul
Project), apoi în ordine: setaþi proprietatea ControlBox la valoarea false, setaþi propri-
etatea Text la “casetã de dialog”, trageþi în formular un control de tip Label ºi Text la
“introdu text”, adãugaþi un control TextBox în formular, adãugaþi douã butoane,
setaþi proprietatea Text a butonului din stânga la “OK” iar al celui din dreapta la
“Cancel”, setaþi proprietatea DialogResult a butonului din stanga la OK iar al celui din
dreapta la Cancel, executaþi clic pe formularul casetei de dialog ºi setaþi proprietatea
AcceptButton la OKButton iar proprietatea CancelButton la CancelButton. Acum exe-
cutaþi dublu clic pe butonul OK ºi folosiþi urmãtorul cod pentru administratorul eveni-
mentului Click:

{
textBoxText = textBox1.Text;
this.Close();
}
Executaþi dublu clic pe butonul Cancel ºi folosiþi urmãtorul cod pentru administra-
torul evenimentului Click:

{
Form2 v = new Form2();
v.ShowDialog();
if (v.DialogResult != DialogResult.OK)
{ this.textBox1.Clear(); }
}
La începutul clasei Form2 adãugaþi declaraþia: public string textBoxText;

Iar la sfãrºitul clasei Form2 adãugaþi proprietatea:
public string TextBoxText

{get{ return(textBoxText);}
Acum puteþi rula acest program.

Crearea interfeþei cu utilizatorul:
Vom crea o aplicaþiei numitã Minicalculator, ce va conþine un meniu principal.
Meniul principal va avea un obiect File ce va conþine câte un obiect Exit ºi Clear.
Ieºirile vor fi afiºate într-un TextBox.
Creaþi o nouã aplicaþie Windows în care trageþi 13 butoane pe care le veþi poziþiona
ºi numi ca în figura alãturatã, apoi mai adãugaþi un TextBox(pe acesta îl puteþi seta
sã arate textul în stânga sau în dreapta).
Adãugaþi un menuStrip care sã conþinã elementele precizate mai sus, ºi pe care le
puteþi observa în figura alãturatã.
Faceþi dublu clic pe fiecare buton numeric în parte pentru a ajunge la sursã ºi mo-
dificaþi fiecare sursã respectând codul de mai jos:

{
string v = textBox1.Text;
v += “7”;
textBox1.Text = v;
}
Am dat exemplu pentru tasta 7, dar atenþie la fiecare tastã, variabila v, va primi ca
valoare numãrul afiºat pe tasta respectivã.
Acum procedaþi la fel, ºi modificaþi sursa pentru butoanele + ºi -.

{
op1 = textBox1.Text;
operatie = “+”;
textBox1.Text = “”;
}
Pentru butonul = folosiþi codul urmãtor:

{
int n1, n2, x = 0;
n1 = Convert.ToInt16(op1);
n2 = Convert.ToInt16(op2);
if (operatie == “+”) { x = n1 + n2; }
else if (operatie == “-”) { x = n1 - n2; }
textBox1.Text = Convert.ToString(x);
op1 = “”; op2 = “”;
}
Codul pentru obiectele Exit ºi Clear din meniul File va fi:
private void clearToolStripMenuItem_Click(object sender, EventArgs e)

{
textBox1.Text = “”;
}
private void exitToolStripMenuItem_Click(object sender, EventArgs e)
{
this.Close();
}
Un alt exemplu:
Se adaugã pe formular douã butoane ºi o casetã text. Apãsarea primului buton va
determina afiºarea textului din TextBox într-un MessageBox iar apãsarea celui de-al
doilea buton va închide închide aplicaþia.
Dupã adãugarea celor douã butoane ºi a casetei text, a fost schimbat textul afiºat
pe cele douã butoane ºi au fost scrise funcþiile de tratare a evenimentului Click pen-
tru 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 infor-

maþie (text, imagine).
Label este folosit pentru plasarea de text pe un formular. Textul afiºat este
conþinut în propietatea Text ºi este aliniat conform propietãþii TextAlign.
TextBox - permite utilizatorului sã introducã un text. Prevede, prin interme-
diul ContextMenu-ului asociat, un set de funcþionalitãþi de bazã, ca de exem-
plu (Cut, Copy, Paste, Delete, SelectAll).
PictureBox permite afiºarea unei imagini.
Exemplul PV2 afiºeazã un grup alcãtuit din 3 butoane, etichetate A,B respectiv C
având iniþial culoarea roºie. Apãsarea unui buton determinã schimbarea culorii aces-
tuia în galben. La o nouã apãsare butonul revine la culoare iniþialã. Acþionarea
butonului “Starea butoanelor” determinã afiºarea într-o casetã text a etichetelor
butoanelor galbene. Caseta text devine vizibilã atunci când apãsãm prima oarã acest
buton. Culoarea butonului mare (verde/portocaliu) se schimbã atunci când mouse-ul
este poziþionat pe buton.
Dupã adãugarea butoanelor ºi a casetei text pe formular, stabilim evenimentele

care determinã schimbarea culoriilor ºi completarea casetei text.

{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’;
}
Exerciþiu Modificaþi aplicaþia precedentã astfel încât sã avem un singur eveniment

button_Click, diferenþierea fiind fãcutã de parametrul sender.
Exerciþiu ( Password) Adãugaþi pe un formular o casetã text în care sã introduceþi
un ºir de caractere ºi apoi verificaþi dacã acesta coincide cu o parolã datã. Textul
introdus în casetã nu este vizibil (fiecare caracter este înlocuit cu*). Rezultatul va fi
afiºat într-un MessageBox.
• Controale de selecþie (CheckBox,RadioButton) au propietatea Checked care

indicã dacã am selectat controlul. Dupã schimbarea stãrii unui astfel de control,
se declanºeazã evenimentul Checked. Dacã propietatea ThreeState este setatã,
atunci se schimbã funcþionalitatea acestor controale, în sensul cã acestea vor
permite setarea unei alte stãri. În acest caz, trebuie verificatã propietatea
CheckState(Checked, Unchecked,Indeterminate) pentru a vedea starea con-
trolului.
Aplicaþia PV3 este un exemplu de utilizare a acestor controale. Soluþia unei probleme
cu mai multe variante de rãspuns este memoratã cu ajutorul unor checkbox-uri cu
proprietatea ThreeState. Apãsarea butonului Verificã determinã afiºarea unei
etichete ºi a butoanelor radio DA ºi NU. Rãspunsul este afiºat într-un MessageBox.
Dupã adãugarea controalelor pe formular ºi setarea proprietãþilor 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;}
Exerciþiu (Test grilã) Construiþi un test grilã care conþine 5 itemi cu câte 4 variante
de rãspuns (alegere simplã sau multiplã), memoraþi rãspunsurile date ºi afiºaþi, dupã
efectuarea testului, într-o casetã text, în dreptul fiecãrui item, rãspunsul corect.
• LinkLabel afiºeazã un text cu posibilitatea ca anumite pãrþi ale textului

(LinkArea) sã fie desenate ca ºi hyperlink-uri. Pentru a face link-ul funcþional tre-
buie tratat evenimentul LinkClicked.
În exemplul PV4, prima etichetã permite afiºarea conþinutului discului C:, a doua
legãturã este un link cãtre 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” );}
Exerciþiu (Memorator) Construiþi o aplicaþie care sã conþinã patru legãturi cãtre

cele patru fiºiere/ pagini care conþin 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ã interfaþa IEnumerable).
În exemplul PV5 elementele selectate din CheckedListBox se adaugã în ListBox.

Dupã adãugarea pe formular a CheckedListBox-ului, stabilim colecþia de itemi
(Properties-Items-Collection), butonul Selecþie ºi ListBox-ul.
Evenimentul Click asociat butonului Setectie goleºte mai întâi listBox-ul

(listBox1.Items.Clear();) ºi dupã aceea adaugã în ordine fiecare element selectat din
CheckedListBox. Suplimentar se afiºeazã o etichetã cu itemii selectaþi.
void button1_Click(object source, System.EventArgs e)

{ String s = “Am selectat si am adaugat itemii: “;
listBox1.Items.Clear();
foreach ( object c in checkedListBox1.CheckedItems)
{listBox1.Items.Add(c);
s = s + c.ToString();s = s + “ “;}
label1.Text = s;}
Exerciþiu (Filtru) Construiþi o aplicaþie care afiºeazã fiºierele dintr-un folder ales
care au un anumit tip (tipul fiºierelor este ales de utilizator pe baza unui
CheckedListBox)
Aplicaþia PV6 este un exemplu de utilizare a controlului ImageList. Apãsarea

butonului Desene va adãuga fiºierele *.gif din folderul C:\Imagini în listã ºi va afiºa
conþinutul acesteia. Butonul Animate va determina afiºarea fiºierelor *.gif cu ajutorul
PictureBox.
ImageList desene_animate = new System.Windows.Forms.ImageList();

private void contruieste_lista_Click(object sender, System.EventArgs e)
{ // Configureaza lista
desene_animate.ColorDepth =System.Windows.Forms.ColorDepth.Depth8Bit;
desene_animate.ImageSize = new System.Drawing.Size(60, 60);
desene_animate.Images.Clear();
string[] gif_uri = Directory.GetFiles(“C:\\Imagini”, “*.gif”);
// se construieste un obiect Imagine pentru fiecare fisier si se adauga la
ImageList.
foreach (string fisier_gif in gif_uri)
{Bitmap desen= new Bitmap (fisier_gif);
desene_animate.Images.Add(desen);pictureBox2.Image=desen;}
Graphics g = this.CreateGraphics();
// Deseneaza fiecare imagine utilizand metoda ImageList.Draw()
for (int i = 0; i < desene_animate.Images.Count; i++)
desene_animate.Draw(g, 60 + i * 60, 60, i);
g.Dispose();
}
Exerciþiu (Thumbnails) Afiºaþi într-o ferestrã conþinutul folder-ului curent în mod

View-Thumbnails.
MonthCalendar afiºeazã un calendar prin care se poate selecta o datã (zi, luna,
an) în mod grafic. Proprietãþile mai importante sunt: MinDate, MaxDate, TodayDate
ce reprezintã data minimã/maximã selectabilã ºi data curentã (care apare afiºatã
diferenþiat sau nu în funcþie de valorile proprietãþilor ShowToday,ShowTodayCircle.
Existã 2 evenimente pe care controlul le expune: DateSelected ºi DateChanged. În
rutinele de tratare a acestor evenimente, programatorul are acces la un obiect de
tipul DateRangeEventArgs care conþine proprietãþile Start ºi End (reprezentând
intervalul de timp selectat).
Formularul din aplicaþia PV7 conþine un calendar pentru care putem selecta un
interval de maximum 30 de zile, sunt afiºate sãptãmânile ºi ziua curentã. Intervalul
selectat se afiºeazã prin intermediul unei etichete. Dacã se selecteazã o datã atunci
aceasta va fi adãugatã ca item într-un ComboBox (orice datã poate apãrea cel mult o
datã în listã).
Dupã adãugarea celor 3 controale pe formular, stabilim proprietãþile pentru
monthCalendar1 (ShowWeekNumber-True, MaxSelectionCount-30, etc.) ºi precizãm
ce se executã atunci când selectãm un interval de timp:
private void monthCalendar1_DateSelected(object sender,

System.Windows.Forms.DateRangeEventArgs e)
{ this.label1.Text = “Interval selectat: Start = “
+e.Start.ToShortDateString() + “ : End = “
+ e.End.ToShortDateString();
if (e.Start.ToShortDateString()==e.End.ToShortDateString())
{String x=e.Start.ToShortDateString();
if(!(comboBox1.Items.Contains(x)))
comboBox1.Items.Add(e.End.ToShortDateString());}
}
• DateTimePicker este un control care (ca ºi MonthCalendar) se poate utiliza pen-

tru a selecta o datã. La clic se afiºeazã un control de tip MonthCalendar, prin care
se poate selecta data doritã. Fiind foarte asemãnãtor cu MonthCalendar, propri-
etãþile prin care se poate modifica comportamentul controlului sunt identice cu
cele ale controlului MonthControl.
Exerciþiu (Formular) Contruiþi un formular de introducere a datelor necesare rea-

lizãrii unei adrese de e-mail. Data naºterii va fi selectatã direct utilizând
MonthCalendar.
• ListView este folosit pentru a afiºa o colecþie de elemente în unul din cele 4
moduri (Text, Text+Imagini mici, Imagini mari, Detalii). Acesta este similar gra-
fic cu ferestrele în care se afiºeazã fiºierele dintr-un anumit director din
Windows Explorer. Fiind un control complex, conþine foarte multe proprietãþi,
printre care: View (selecteazã modul de afiºare (LargeIcon, SmallIcon, Details,
List)), LargeImageList, SmallImageList (icon-urile de afiºat în modurile
LargeIcon, SmallIcon), Columns(utilizat doar în modul Details, pentru a defini
coloanele de afiºat), Items(elementele de afiºat).
Aplicaþia PV8 este un exemplu de utilizare ListView. Se porneºte de la rãdãcinã ºi

se afiºeazã conþinutul folder-ului selectat cu dublu clic. La expandare se afiºeazã
numele complet, data ultimei accesãri ºi, în cazul fiºierelor, dimensiunea.
Controlul lista_fisiere este de tip ListView.
Funcþia ConstruiesteHeader permite stabilirea celor trei coloane de afiºat.
private void ConstruiesteHeader()

{ColumnHeader colHead;colHead = new ColumnHeader();
colHead.Text = “Nume fisier”;
this.lista_fisiere.Columns.Add(colHead);
colHead = new ColumnHeader();colHead.Text = “Dimensiune”;
his.lista_fisiere.Columns.Add(colHead);
colHead = new ColumnHeader();colHead.Text = “Ultima accesare”;
this.lista_fisiere.Columns.Add(colHead);
}
Pentru item-ul selectat se afiºeazã mai întâi folderele ºi dupã aceea fiºierele.
Pentru aceasta trebuie sã determinãm conþinutul acestuia:
ListViewItem lvi;
ListViewItem.ListViewSubItem lvsi;
this.calea_curenta.Text = radacina + “(Doublu Click pe folder)”;
System.IO.DirectoryInfo dir = new System.IO.DirectoryInfo(radacina);
DirectoryInfo[] dirs = dir.GetDirectories();
FileInfo[] files = dir.GetFiles();
sã ºtergem vechiul conþinut al listei:
this.lista_fisiere.Items.Clear();
this.lista_fisiere.BeginUpdate();
ºi sã adãugãm fiecare nou item ( coloana a doua este vidã în 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);
}
Exerciþiu (Ordonare) Modificaþi aplicaþia anterioarã astfel încât apãsarea pe

numele unei coloane sã determine afiºarea informaþiilor ordonate dupã criteriul
specificat (nume, dimensiune, data).
• Controale ”de control” al executãrii (Timer) sau de dialog (OpenFileDialog,

SaveFileDialog, ColorDialog, FontDialog, ContextMenu).
Utilizatorul nu are drept de control asupra tuturor controalelor. Dintre acestea vom
studia în cele ce urmeazã controlul Timer asupra cãruia are drept de interacþiune doar
cel care dezvoltã aplicaþia.
Observãm cã aducând din Toolbox controlul Timer, acesta nu se afiºeazã pe formu-

lar, el apãrând într-o zonã gri a suprafeþei de lucru (Designer).
Vom stabili urmãtoarele proprietãti legate de Timer:
Proprietate Valoare Explicaþie

(Name) aplCeas
Enabled True Activarea controlului de timp
Numãrul de milisecunde dintre apelurile
la metoda de tratare a evenimentului.
Interval 1.000
Se stabileºte, în cazul de faþã numãrã-
toarea din secundã în secundã
Aducem în formular un control Label cu urmãtoarele proprietãþi:
Control Proprietate Valoare

label1 (Name) labelCeas
AutoSize False
BorderStyle Fixed3D
FontSize 16,25, Bold
Location 82;112
Text
Size 129;42
TextAlign MiddleCenter
Dãm clic pe icoana de la timer care are numele aplCeas, iar la Events, la Tick selec-
tãm lblCeas_Click
Dãm dublu clic pe label ºi inserãm codul:
private void lblCeas_Click(object sender, EventArgs e)

{
DateTime OraCurenta = DateTime.Now;
lblCeas.Text=OraCurenta.ToLongTimeString();
}
Compilãm ºi obþinem într-o fereastrã vizualizarea orei sistemului.
În urmãtorul exemplu vom folosi ProgressBar pentru a vizualiza ceasul sistemului.

Vom construi un formular ca în imaginea alãturatã. Pentru aceasta aducem din
Toolbox trei controale ProgressBar, un control Timer, ºapte controale Label ºi un con-
trol Button. Tabelul de mai jos descrie proprietãþile ºi valorile formularului ºi a respec-
tivelor controale:
Formularul:

Form1 (Name) Form1
Size 606;265
BorderStyle Fixed3D
Text Afiºare timp cu ProgressBar si Label
ProgressBar-urile:

ProgressBar1 (Name) prgOre
Location 82;64
Maximum 23
Size 431;23
Step 1
Style Blocks

ProgressBar2 (Name) prgMinute
Location 82;106
Maximum 59
Size 431;23
Step 1
Style Blocks
ProgressBar3 (Name) prgSecunde
Location 82;144
Maximum 59
Size 431;23
Step 1
Style Blocks
Pentru afiºarea textelor „Ore”, „Minute”, „Secunde” folosim:

Label1 (name) lblOre
Autosize False
BorderStyle None
Locations 22;64
Size 54;23
Text Ore
TextAlign MiddleLeft
Label2 (name) lblMinute
Autosize False
BorderStyle None
Locations 22;104
Size 54;23
Text Minute
Label3 (name) lblSecunde
Autosize False
BorderStyle None
Locations 22;144
Size 54;23
Text Minute
Pentru „Ieºire” folosim:

Button1 (Name) btnIesire
Location 25;198
Size 75;23
Text Iesire
Pentru informaþiile din partea dreaptã a formularului:

Label4 (name) lblTextTimp
Autosize False
Locations 523;10
Size 54;23
Text Timp
Label5 (name) lblAfisOre
Autosize False
BorderStyle Fixed3D
Locations 523;64
Size 54;23
Text 00
Label6 (name) lblAfisMinute
Autosize False
BorderStyle Fixed3D
Locations 523;106
Size 54;23
Text 00
Label4 (name) lblAfisSecunde
Autosize False
BorderStyle Fixed3D
Locations 523;144
Size 54;23
Text 00
Pentru Timer:
Control Proprietate Valoare Evenimente
Timer1 (Name) Timer1 Timer1_Tick
Enabled True
Interval 1.000
pentru timer1:
private void timer1_Tick(object sender, EventArgs e)

{
DateTime TimpCurent = DateTime.Now;
int H = TimpCurent.Hour;
int M = TimpCurent.Minute;
int S = TimpCurent.Second;
prgOre.Value = H;
prgMinute.Value = M;
prgSecunde.Value = S;
lblAfisOre.Text = H.ToString();
lblAfisMinute.Text = M.ToString();
lblAfisSecunde.Text = S.ToString();
}
pentru a redimensiona proporþional ProgressBar-ul Ore cu cel care reprezintã
Minutele, respectiv Secundele, introducem urmãtorul cod:
private void Form1_Load(object sender, EventArgs e)

{
this.prgOre.Width = 2 * this.prgMinute.Width
/ 5;
}
pentru butonul de Ieºire:
private void btnIesire_Click(object sender, EventArgs e)

{
Close();
}
Compilãm ºi obþinem ora sistemului afiºatã într-o fereastrã de forma:
• Grupuri de controale Toolbar (ToolStrip) afiºeazã o barã de butoane în partea de

sus a unui formular. Se pot introduce vizual butoane (printr-un designer, direct
din Visual Studio.NET IDE), la care se pot seta atât textul afiºat sau imaginea.
Evenimentul cel mai util al acestui control este ButtonClick (care are ca para-
metru un obiect de tip ToolBarButtonClickEventArgs, prin care programatorul
are acces la butonul care a fost apasat).
În aplicaþia urmãtoare PV9 cele 3 butoane ale toolbar-ului permit modificarea pro-
prietãþilor textului introdus în casetã. Toolbar-ul se poate muta fãrã a depãºi spaþiul
ferestrei. Schimbarea fontului se realizeazã cu ajutorul unui control FontDialog(),iar
schimbarea culorii utilizeazã ColorDialog()
FontDialog fd = new FontDialog();

fd.ShowColor = true;fd.Color = Color.IndianRed;
fd.ShowApply = true;
fd.Apply += new EventHandler(ApplyFont);
if(fd.ShowDialog() !=
System.Windows.Forms.DialogResult.Cancel)
{ this.richTextBox1.Font= fd.Font;
this.richTextBox1.ForeColor=fd.Color;
}
ColorDialog cd = new ColorDialog();
cd.AllowFullOpen = true;cd.Color = Color.DarkBlue;
if(cd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
this.richTextBox1.ForeColor = cd.Color;
Mutarea toolbar-ul este dirijatã de evenimentele produse atunci când apãsãm

butonul de mouse ºi/sau ne deplasãm pe suprafaþa ferestrei.
private void toolBar1_MouseDown(object sender, MouseEventArgs e)

{ // am apasat butonul de mouse pe toolbar
am_apasat = true;
forma_deplasata = new Point(e.X, e.Y); toolBar1.Capture = true;}
private void toolBar1_MouseUp(object sender, MouseEventArgs e)
{ am_apasat = false;toolBar1.Capture = false;}
private void toolBar1_MouseMove(object sender, MouseEventArgs e)
{ if (am_apasat)
{ if(toolBar1.Dock == DockStyle.Top || toolBar1.Dock == DockStyle.Left)
{ // daca depaseste atunci duc in stanga sus
if (forma_deplasata.X < (e.X-20) || forma_deplasata.Y < (e.Y-20))
{ am_apasat = false;// Disconect toolbar
toolBar1.Dock = DockStyle.None;
toolBar1.Location = new Point(10, 10);
toolBar1.Size = new Size(200, 45);
toolBar1.BorderStyle = BorderStyle.FixedSingle;
}
}
else if (toolBar1.Dock == DockStyle.None)
{toolBar1.Left = e.X + toolBar1.Left - forma_deplasata.X;
toolBar1.Top = e.Y + toolBar1.Top - forma_deplasata.Y;
if (toolBar1.Top < 5 || toolBar1.Top>this.Size.Height-20)
{ am_apasat = false;toolBar1.Dock = DockStyle.Top;
toolBar1.BorderStyle = BorderStyle.Fixed3D;}
else if (toolBar1.Left < 5 || toolBar1.Left > this.Size.Width - 20)
{ am_apasat = false;toolBar1.Dock = DockStyle.Left;
toolBar1.BorderStyle = BorderStyle.Fixed3D;
}}}
}
Exerciþiu (Editor) Realizaþi un editor de texte care conþinã un control toolBar cu

butoanele uzuale.
• Controale container (GroupBox, Panel, TabControl) sunt controale ce pot

conþine alte controale.
Aplicaþia PV10 simuleazã lansarea unei comenzi cãtre un magazin de jucãrii. Se

utilizeazã 4 pagini de Tab pentru a simula selectarea unor opþiuni ce se pot grupa pe
categorii.
Exerciþiu (Magazin) Dezvoltaþi aplicaþia precedentã astfel încât pe o paginã sã se

afiºeze modelele disponibile (imagine+detalii) ºi sã se permitã selectarea mai mul-
tor obiecte. Ultima paginã reprezintã coºul de cumpãrãturi.
• Grupuri de controale tip Meniu (MenuStrip, ContextMenuStrip etc.)

Un formular poate afiºa un singur meniu principal la un moment dat, meniul aso-
ciat iniþial fiind specificat prin propietatea Form.MainMenuStrip. Meniul care este
afiºat de cãtre un formular poate fi schimbat dinamic la rulare:
switch(cond) { case cond1:this.MainMenuStrip = this.mainMenu1;break;

case cond2:this.MainMenuStrip = this.mainMenu2;
}
unde mainMenu1 ºi mainMenu2 sunt obiecte de tip MenuStrip. Editarea unui ast-
fel de obiect se poate face utilizând Menu Designer. Clasa MenuStrip are o colecþie
de MenuItem care conþine 0 sau mai multe obiecte de tip MenuItem. Fiecare dintre
aceste obiecte de tip MenuItem are 0 sau mai multe obiecte de tip MenuItem, care
vor constitui noul nivel de itemi (Ex: File ÆNew,Save, Open, Close, Exit).
Propietãþile Checked ºi RadioCheck indicã itemul selectat, Enabled and Visible
determinã dacã un item poate fi sau nu selectat sau vizibil, Shortcut permite
asignarea unei combinaþii de taste pentru selectarea unui item al meniului ºi Text
memoreazã textul care va fi afiºat pentru respectivul item al meniului.

Evenimentul Click are loc când un utilizator apasã un item al meniului.
Exemplul PV11 permite, prin intermediul unui meniu, scrierea unui fiºier Notpad,
afiºarea continutului acestuia într-o casetã text, schimbarea fontului ºi culorii de
afiºare, ºtergerea conþinutului casetei, afiºarea unor informaþii teoretice precum ºi
Help dinamic. Au fost definite chei de acces rapid pentru accesarea componentelor
meniului.
FileÆ New permite scrierea unui fiºier notepad nou
System.Diagnostics.Process.Start( “notepad” );
FileÆ Open selecteazã ºi afiºeazã în caseta text conþinutul unui fiºier text.
OpenFileDialog of = new OpenFileDialog();

of.Filter = “Text Files (*.txt)|*.txt”;
of.Title = “Fisiere Text”;
if (of.ShowDialog() == DialogResult.Cancel)return;
richTextBox1.Text=””;richTextBox1.Visible=true;
FileStream strm;
try{strm = new FileStream (of.FileName, FileMode.Open, FileAccess.Read);
StreamReader rdr = new StreamReader (strm);
while (rdr.Peek() >= 0){string str = rdr.ReadLine ();
richTextBox1.Text=richTextBox1.Text+” “+str;}
}
catch (Exception){MessageBox.Show (“Error opening file”, “File Error”,
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);}
FileÆ Close ºterge conþinutul casetei text, FileÆ Exit închide aplicaþia
Window Æ Font ºi Window ÆColor permit stabilirea fontului/culorii textului afiºat.
HelpÆ DinamicHelp acceseazã
System.Diagnostics.Process.Start(“IExplore”,
“http://msdn2.microsoft.com/en-us/default.aspx”);
HelpÆ About PV afiºeazã în caseta text informaþii despre implementarea unui menu.
Exerciþiu (Fisiere) Contruiþi un menu care sã permitã efectuarea operaþiilor uzuale

cu fiºiere.
5.5. System.Drawing
Spaþiul System.Drawing conþine tipuri care permit realizarea unor desene 2D ºi au rol
deosebit în proiectarea interfeþelor grafice.
Un obiect de tip Point este reprezentat prin coordonatele unui punct într-un spaþiu
bidimensional (exemplu: Point myPoint = new Point(1,2);)
Point este utilizat frecvent nu numai pentru desene, ci ºi pentru a identifica în pro-
gram un punct dintr-un anumit spaþiu. De exemplu, pentru a modifica poziþia unui
buton în fereastrã putem asigna un obiect de tip Point proprietãþii Location indicând
astfel poziþia colþului din stânga-sus al butonului (button.Location = new Point(100, 30)).
Putem construi un obiect de tip Point pentru a redimensiona un alt obiect.
Size mySize = new Size(15, 100);

Point myPoint = new Point(mySize);
System.Console.WriteLine(“X: “ + myPoint.X + “, Y: “ + myPoint.Y);
Structura Color conþine date, tipuri ºi metode utile în lucrul cu culori. Fiind un tip
valoare (struct) ºi nu o clasã, aceasta conþine date ºi metode, însã nu permite
instanþiere, constructori, destructor, moºtenire.
Color myColor = Color.Brown; button1.BackColor = myColor;
Substructura FromArgb a structurii Color returneazã o culoare pe baza celor trei

componente ale oricãrei culori (red, green, blue).
Clasa Graphics este o clasã sigilatã reprezentând o arie rectangularã care permite
reprezentãri grafice. De exemplu, o linie frântã 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);
Aplicaþia PV12 este un exerciþiu care deseneazã cercuri de raze ºi culori aleatorii ºi
emite sunete cu frecvenþã aleatoare.
Random x = new Random();

Console.Beep(300 + x.Next(1000), 150);
Graphics g = e.Graphics;
i = 1 + x.Next(30);
p=new Pen(System.Drawing.Color.FromArgb(x.Next(256),x.Next(256),x.Next(256)))
g.DrawEllipse(p, x.Next(100), x.Next(100), i, i);

Console.Sleep(200);
În exemplul PV13 se construieºte o pictogramã pe baza unei imagini.
Image thumbnail;
private void Thumbnails_Load(object sender, EventArgs e)
{ try{Image img = Image.FromFile(“C:\\Imagini\\catel.jpg”);
int latime=100, inaltime=100;
thumbnail=img.GetThumbnailImage(latime, inaltime,null, IntPtr.Zero);}
catch{MessageBox.Show(“Nu exista fisierul”);}
}
private void Thumbnails_Paint(object sender, PaintEventArgs e)
{e.Graphics.DrawImage(thumbnail, 10, 10);}
5.6. Validarea informaþiilor de la utilizator

Înainte ca informaþiile de la utilizator sã fie preluate ºi transmise cãtre alte clase,
este necesar sã fie validate. Acest aspect este important, pentru a preveni posibilele
erori. Astfel, dacã utilizatorul introduce o valoare realã (float) când aplicaþia aºteaptã
un întreg (int), este posibil ca aceasta sã se comporte neprevãzut abia câteva secunde
mai târziu, ºi dupã multe apeluri de metode, fiind foarte greu de identificat cauza pri-
marã a problemei.
Validarea la nivel de câmp
Datele pot fi validate pe mãsurã ce sunt introduse, asociind o prelucrare unuia
dintre handlerele asociate evenimentelor la nivel de control (Leave, Textchanged,

MouseUp etc.)
private void textBox1_KeyUp(object sender,

System.Windows.Forms.KeeyEventArgs e)
{if(e.Alt==true) MessageBox.Show (“Tasta Alt e apasata”); // sau
if(Char.IsDigit(e.KeyChar)==true) MessageBox.Show(“Ati apasat o cifra”);
}
Validarea la nivel de utilizator

În unele situaþii (de exemplu atunci când valorile introduse trebuie sã se afle într-o
anumitã relaþie între ele), validarea se face la sfârºitul 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.
Urmãriþi aplicaþiile ºi precizaþi pentru fiecare dintre ele controalele utilizate, eveni-
mentele tratate: Forma poloneza (PV14), Triunghi (PV15), Ordonare vector(PV16),
Subsir crescãtor de lungime maximã(PV17), Jocul de Nim (PV18)
Exerciþiu (Test grila) Realizaþi un generator de teste grilã (întrebãrile sunt preluate
dintr-un fiºier text, pentru fiecare item se precizeazã tipul (alegere simplã/multiplã),
punctajul, enunþul ºi distractorii, imaginea asociatã (dacã existã). Dupã efectuarea
testului se afiºeazã rezultatul obþinut ºi statistica rãspunsurilor.
89
CAPITOLUL 6
ADO.NET
ADO.NET (ActiveX Data Objects) reprezintã o parte componentã a nucleului .NET
Framework ce permite conectarea la surse de date diverse, extragerea, manipularea
ºi actualizarea datelor.
De obicei, sursa de date este o bazã de date, dar ar putea de asemenea sã fie un
fiºier text, o foaie Excel, un fiºier Access sau un fiºier XML.
În aplicaþiile tradiþionale cu baze de date, clienþii stabilesc o conexiune cu baza de
date ºi menþin aceastã conexiune deschisã pânã la încheierea executãrii aplicaþiei.
Conexiunile deschise necesitã alocarea de resurse sistem. Atunci când menþinem
mai multe conexiuni deschise server-ul de baze de date va rãspunde mai lent la
comenzile clienþilor întrucât cele mai multe baze de date permit un numãr foarte mic
de conexiuni concurente.
ADO.NET permite ºi lucrul în stil conectat dar ºi lucrul în stil deconectat, aplicaþiile
conectându-se la server-ul de baze de date numai pentru extragerea ºi actualizarea
datelor. Acest lucru permite reducerea numãrului de conexiuni deschise simultan la
sursele de date.
ADO.NET oferã instrumentele de utilizare ºi reprezentare XML pentru transferul
datelor între aplicaþii ºi surse de date, furnizând o reprezentare comunã a datelor,
ceea ce permite accesarea datelor din diferite surse de diferite tipuri ºi prelucrarea lor
ca entitãþi, fãrã sã fie necesar sã convertim explicit datele în format XML sau invers.
Aceste caracteristici sunt determinate în stabilirea beneficiilor furnizate de
ADO.NET:
• Interoperabilitate. ADO.NET poate interacþiona uºor cu orice componentã care
suportã XML.
• Durabilitate. ADO.NET permite dezvoltarea arhitecturii unei aplicaþii datoritã
modului de transfer a datelor între nivelele arhitecturale.
• Programabilitate.ADO.NET simplificã programarea pentru diferite task-uri cum
ar fi comenzile SQL, ceea ce duce la o creºtere a productivitãþii ºi la o scãdere a
numãrului de erori.
• Performanþã. Nu mai este necesarã conversia explicitã a datelor la transferul
între aplicaþii, fapt care duce la creºte performanþelor acestora.
• Accesibilitate Utilizarea arhitecturii deconectate permite accesul simultan la
acelaºi set de date. Reducerea numãrului de conexiuni deschise simultan deter-
minã utilizarea optimã a resurselor.
6.1. Arhitectura ADO.NET

Componentele principale ale ADO.NET sunt DataSet ºi Data Provider. Ele au fost
proiectate pentru accesarea ºi manipularea datelor.
6.2. Furnizori de date (Data Providers)

Din cauza existenþei mai multor tipuri de surse de date este necesar ca pentru
fiecare tip de protocol de comunicare sã se foloseascã o bibliotecã specializatã de
clase.
.NET Framework include SQL Server.NET Data Provider pentru interacþiune cu
Microsoft SQL Server, Oracle Data Provider pentru bazele de date Oracle ºi OLE DB
Data Provider pentru accesarea bazelor de date ce utiliteazã tehnologia OLE DB pen-
tru expunerea datelor (de exemplu Access, Excel sau SQL Server versiune mai veche
decât 7.0)
Furnizorul de date permite unei aplicaþii sã se conecteze la sursa de date, executã
comenzi ºi salveazã rezultate. Fiecare furnizor de date cuprinde componentele
Connection, Command, DataReader ºi DataAdapter.
6.3.Connection.
Înainte de orice operaþie cu o sursã de date externã, trebuie realizatã o conexiune
(legãturã) cu acea sursã. Clasele din categoria Connection (SQLConnection,
OleDbConnection etc.) conþin date referitoare la sursa de date (locaþia, numele ºi
parola contului de acces, etc.), metode pentru deschiderea/închiderea conexiunii,
pornirea unei tranzacþii etc. Aceste clase se gãsesc în subspaþii (SqlClient, OleDb etc.)
ale spaþiului System.Data. În plus, ele implementeazã interfaþa IdbConnection.
Pentru deschiderea unei conexiuni prin program se poate instanþia un obiect de tip
conexiune, precizându-i ca parametru un ºir de caractere conþinând date despre
conexiune.
CAPITOLUL 6. ADO.NET 91
6.3.1. Exemple de conectare

Ex.1) conectare la o sursã de date SQL
using System.Data.SqlClient;
SqlConnection co = new SqlConnection();
co.ConnectionString = “Data Source=localhost; User ID=profesor;pwd=info; Initial
Catalog=Orar”;
co.Open();
Ex.2) conectare la o sursã de date SQL
SqlConnection co =
new SqlConnection(@”Data Source=serverBD;Database=scoala;User
ID=elev;Password=madonna”);
co.Open();
Ex.3) conectare la o sursã de date Access
using System.Data.OleDb;
OleDbConnection co =
new OleDbConnection(@”Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=C:\Date\scoala.mdb”);
co.Open();
6.3.2. Proprietãþi
a) ConnectionString (String, cu accesori de tip get ºi set ) defineºte un ºir care per-
mite identificarea tipului ºi sursei de date la care se face conectarea ºi eventual
contul ºi parola de acces. Conþine lista de parametri necesarii conectãrii sub
forma parametru=valoare, separaþi prin ;.
Parametru Descriere
Specificã furnizorul de date pentru conectarea la sursa de date. Acest furnizor
Provider trebuie precizat doar dacã se foloseºte OLE DB .NET Data Provider,
ºi nu se specificã pentru conectare la SQL Server.
Identificã serverul, care poate fi local,
Data Source
un domeniu sau o adresa IP.
specificã numele bazei de date. Baza de date trebuie sã se gãseascã pe
Initial Catalog
serverul dat în Data Source
Integrated Security32 Logarea se face cu user-ul configurat pentru Windows.
User ID Numele unui user care are acces de logare pe server
Password Parola corespunzãtoare ID-ului specificat.
b) ConnectionTimeout (int, cu accesor de tip get): specificã numãrul de secunde pen-

tru care un obiect de conexiune poate sã aºtepte pentru realizarea conectãrii la
32 User Id ºi Password pot înlocui parametrul Integrated Security

server înainte de a se genera o excepþie. (implicit 15). Se poate specifica o

valoare diferitã de 15 în ConnectionString folosind parametrul Connect Timeout,
Valoarea Timeout=0 specificã aºteptare nelimitatã.
Ex.) using System.Data.SqlClient;

SqlConnection cn = new SqlConnection(“Data Source=serverBD;
Database=scoala;User ID=elev;Password=madonna; Connect Timeout=30”);
c) Database (string, read-only): returneazã numele bazei de date la care s–a fãcut
conectarea. Este necesarã pentru a arãta unui utilizator care este baza de date
pe care se face operarea
d)Provider (de tip string, read-only): returneazã furnizorul de date
e) ServerVersion (string, read-only): returneazã versiunea de server la care s-a fãcut
conectarea.
f) State (enumerare de componente ConnectionState, read-only): returneazã
starea curentã a conexiunii. Valorile posibile: Broken, Closed, Connecting,
Executing, Fetching, Open.
6.3.3. Metode
a) Open(): deschide o conexiune la baza de date
b)Close() ºi Dispose(): închid conexiunea ºi elibereazã toate resursele alocate pen-
tru ea
c) BeginTransaction(): pentru executarea unei tranzacþii pe baza de date; la sfârºit
se apeleazã Commit() sau Rollback().
d)ChangeDatabase(): se modificã baza de date la care se vor face conexiunile. Noua
bazã de date trebuie sã existe pe acelaºi server ca ºi precedenta.
e) CreateCommand(): creeazã o comandã (un obiect de tip Command) validã asoci-
atã conexiunii curente.
6.3.4. Evenimente
a) StateChange: apare atunci când se schimbã starea conexiunii. Handlerul cores-
punzãtor (de tipul delegat StateChangeEventHandler) spune între ce stãri s-a
fãcut tranziþia.
b) InfoMessage: apare când furnizorul trimite un avertisment sau un mesaj cãtre client.
6.4. Command
Clasele din categoria Command (SQLCommand, OleDbCommand etc.) conþin date
referitoare la o comandã SQL (SELECT, INSERT, DELETE, UPDATE) ºi metode pentru
executarea unei comenzi sau a unor proceduri stocate. Aceste clase implementeazã
interfaþa IDbCommand. Ca urmare a interogãrii unei baze de date se obþin obiecte din
categoriile DataReader sau DataSet. O comandã se poate executa numai dupã ce s-a
stabilit o conxiune cu baza de date corespunzãtoare.
a) CommandText (String): conþine comanda SQL sau numele procedurii stocate care
se executã pe sursa de date.
b)CommandTimeout (int): reprezintã numãrul de secunde care trebuie sã fie aºteptat
pentru executarea comenzii. Dacã se depãºeste acest timp, atunci se genereazã
o excepþie.
c) 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 obiºnuitã), TableDirect (numai
pentru OleDb)
d)Connection (System. Data. [Provider].PrefixConnection): conþine obiectul de tip
conexiune folosit pentru legarea la sursa de date.
e) Parameters (System.Data.[Provider].PrefixParameterCollection): returneazã o
colecþie de parametri care s-au transmis comenzii.
f) Transaction (System.Data.[Provider].PrefixTransaction): permite accesul la
obiectul de tip tranzacþie care se cere a fi executat pe sursa de date.
6.4.2. Metode
a) Constructori:
SqlCommand()
SqlCommand(string CommandText)
SqlCommand(string CommandText, SqlConnection con )
SqlCommand(string CommandText,SqlConnection con,SqlTransaction trans)
b)Cancel() opreºte o comandã aflatã în executare.
c) Dispose() distruge obiectul comandã.
d)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ã
numãrul de înregistrãri afectate.
Exemplu:
SqlCommand cmd = new SqlCommand();
cmd.CommandText = “DELETE FROM elevi WHERE nume = ’BARBU’”;
cmd.Connection = con;
Console.WriteLine(cmd.ExecuteNonQuery().ToString());
//câte înreg. s-au sters
e) ExecuteReader() executã comanda ºi returneazã un obiect de tip DataReader.
Exemplu
Se obþine conþinutul tabelei elevi într-un obiect de tip SqlDataReader.
SqlCommand cmd = new SqlCommand(“SELECT * FROM elevi”,con);
SqlDataReader reader = cmd.ExecuteReader();
while(reader.Read()) { Console.WriteLine(“{0} - {1}”,
reader.GetString(0),reader.GetString(1));
}
reader.Close();
Metoda ExecuteReader() mai are un argument opþional de tip enumerare,

CommandBehavior, care descrie rezultatele ºi efectul asupra bazei de date:
CloseConnection (conexiunea este închisã atunci când obiectul DataReader este
închis),
KeyInfo (returnezã informaþie despre coloane ºi cheia primarã),
SchemaOnly (returnezã doar informaþie despre coloane),
SequentialAccess (pentru manevrarea valorilor binare cu GetChars() sau
GetBytes()),
SingleResult (se returneazã un singur set de rezultate),
SingleRow (se returneazã o singurã linie).
f) ExecuteScalar() executã comanda ºi returneazã valoarea primei coloane de pe primul

rând a setului de date rezultat; folosit pentru obþinerea unor rezultate statistice.
Exemplu:
SqlCommand cmd = new SqlCommand(“SELECT COUNT(*) FROM elevi”,con);

SqlDataReader reader = cmd.ExecuteScalar();
Console.WriteLine(reader.GetString(0));
f) ExecuteXmlReader() returneazã un obiect de tipul XmlReader obþinut prin

interogare
Exemplu:
SqlCommand CMD=
new SqlCommand(“SELECT * FROM elevi FOR XML MATE,EXAMEN”, con);
System.Xml.XmlReader myXR = CMD.ExecuteXmlReader();
Obiectele de tip SQLCommand pot fi utilizate într-un scenariu ce presupune

deconectarea de la sursa de date dar ºi în operaþii elementare care presupun
obþinerea unor rezultate imediate.
Vom exemplifica utilizarea obiectelor de tip Command în operaþii ce corespund
acestui caz.
Presupunem cã am stabilit conexiunea:
SqlConnection conn =
new SqlConnection(@”Data Source=serverBD;Database=MAGAZIN;User ID=adm;Password=eu”);
conn.Open();
ºi cã tabela PRODUSE are câmpurile ID_PRODUS, DENUMIRE_PRODUS, DESCRIERE

Instanþierea unui obiect de tip SQLCommnand
SqlCommand cmd = new SqlCommand(“select DENUMIRE_PRODUS from PRODUSE”, conn);
conþine un string ce precizeazã comanda care se executã ºi o referinþã cãtre obiec-

tul SQLConnection.
6.4.3. Interogarea datelor.

Pentru extragerea datelor cu ajutorul unui obiect SqlCommand trebuie sã utilizãm
metoda ExecuteReader care returneazã un obiect SqlDataReader.
// Instantiem o comandã cu o cerere si precizam conexiunea

SqlCommand cmd = new SqlCommand(“select DENUMIRE_PRODUS from PRODUSE”, conn);
// Obtinem rezultatul cererii
SqlDataReader rdr = cmd.ExecuteReader();
6.4.4. Inserarea datelor.

Pentru a insera date într-o bazã de date utilizãm metoda ExecuteNonQuery a
obiectului SqlCommand.
// Sirul care pãstreazã comanda de inserare

string insertString = @”insert into PRODUSE(DENUMIRE_PRODUS, DESCRIERE)
values (‘Barbie’, ‘papusa’)”;
// Instantiem o comandã cu acestã cerere si precizãm conexiunea
SqlCommand cmd = new SqlCommand(insertString, conn);
// Apelãm metoda ExecuteNonQuery pentru a executa comanda
cmd.ExecuteNonQuery();
Facem observaþia cã am specficat explicit numai coloanele DENUMIRE_PRODUS ºi

DESCRIERE. Tabela PRODUSE are cheia primarã ID_PRODUS. Valoarea acestui câmp va
fi atribuitã de SQL Server. Dacã încercãm sã adãugãm o valoare atunci va fi generatã
o excepþie.
6.4.5. Actualizarea datelor.

// Sirul care pãstreazã comanda de actualizare
string updateString = @”update PRODUSE set DENUMIRE_PRODUS = ‘Locomotiva Thomas’
where DENUMIRE_PRODUS = ‘Thomas’”;
// Instantiem o nouã comandã fãrã sã precizãm conexiunea
SqlCommand cmd = new SqlCommand(updateString);
// Stabilim conexiunea
cmd.Connection = conn;33
// Apelãm ExecuteNonQuery pentru executarea comenzii
6.4.6. ªtergerea datelor.

Se utilizeazã aceeaºi metodã ExecuteNonQuery.
// sirul care pãstreazã comanda de ºtergere

string deleteString = @”delete from PRODUSE where DENUMIRE_PRODUS = ‘Barbie’”;
// Instanþiem o comandã
SqlCommand cmd = new SqlCommand();34
// Setãm proprietatea CommandText
cmd.CommandText = deleteString;
// Setãm proprietatea Connection
cmd.Connection = conn;
// . Executãm comanda
Câteodatã avem nevoie sã obþinem din baza de date o singurã valoare, care poate
fi o sumã, o medie sau alt rezultat al unei funcþii agregat. O alegere ineficientã ar fi
utilizarea metodei ExecuteReader ºi apoi calculul valorii. În acest caz, cea mai bunã
alegere este sã lucrãm direct asupra bazei de date ºi sã obþinem aceastã valoare.
// Instantiem o comandã nouã

SqlCommand cmd = new SqlCommand(“select count(*) from PRODUSE”, conn);
// Executãm comanda si obtinem valoarea
int count = (int)cmd.ExecuteScalar();35
Exerciþii:
1) Realizaþi o conexiune la baza de date MAGAZIN ºi afiºaþi ID-urile produselor.
using System;
using System.Data;
class ADO1
{
static void Main()
{ SqlConnection conn = new SqlConnection(
“Data Source=(local);Initial Catalog=MAGAZIN;Integrated Security=SSPI”);
SqlDataReader rdr = null;
try
{ conn.Open();
SqlCommand cmd = new SqlCommand(“select * from PRODUSE”, conn);
33 Am fi putut folosi acelaºi constructor ca la Insert. Acest exemplu demonstreazã cã putem schimba oricând obiec-
tul connection asignat unei comenzi
34 În acest exemplu am ales sã aplelã constructorul SqlCommand fãrã parametri, pentru a exemplifica cum putem
stabili explicit conexiunea ºi comanda
35 Este necesarã conversia întrucât rezultatul returnat de ExecuteScalar este de tip object
rdr = cmd.ExecuteReader();
while (rdr.Read()) { Console.WriteLine(rdr[0]);}
}
finally
{ if (rdr != null) {rdr.Close();}
if (conn != null){conn.Close();}
}
}
}
2) Realizaþi funcþii care sã implementeze operaþiile elementare asupra unei baze

de date ºi verificaþi funcþionalitatea lor.
using System;
using System.Data;
class ADO2
{
SqlConnection conn;
public ADO2()
{ conn = new SqlConnection(“Data Source=(local);Initial
Catalog=MAGAZIN;Integrated Security=SSPI”);
}
static void Main()
{
ADO2 scd = new ADO2();
Console.WriteLine(“Produse aflate în magazin înainte de Insert”);
scd.ReadData();scd.Insertdata();
Console.WriteLine(“Produse aflate în magazin dupa Insert”);
scd.ReadData();scd.UpdateData();
Console.WriteLine(“Produse aflate în magazin dupa Update”);
scd.ReadData();scd.DeleteData();
Console.WriteLine(“Categories After Delete”);
scd.ReadData();
int number_inregistrari = scd.GetNumberOfRecords();
Console.WriteLine(“Numarul de inregistrari: {0}”, numar_inregistrari);
}
public void ReadData()
{ SqlDataReader rdr = null;
try
{conn.Open();
SqlCommand cmd = new SqlCommand(“select DENUMIRE_PRODUS from PRODUSE”,
conn);
while (rdr.Read()) {Console.WriteLine(rdr[0]);}
}
finally
{ if (rdr != null){rdr.Close();}
}
}
public void Insertdata()
{try
{conn.Open();
string insertString = @”insert into PRODUSE(DENUMIRE_PRODUS, DESCRIERE)
values (‘SCOOBY’, ‘jucarie de plus’)”;
SqlCommand cmd = new SqlCommand(insertString, conn);
}
finally
{if (conn != null){conn.Close();}
}
}
public void UpdateData()
{
try
{conn.Open();
string updateString = @”update PRODUSE set DENUMIRE_PRODUS = ‘SCOOBY DOO’
where DENUMIRE_PRODUS = ‘SCOOBY’”;
SqlCommand cmd = new SqlCommand(updateString);
}
finally
}
}
public void DeleteData()
{ try
{ conn.Open();
string deleteString = @”delete from PRODUSE where DENUMIRE_PRODUS = ‘BAR-
BIE’”;
SqlCommand cmd = new SqlCommand();
cmd.CommandText = deleteString;
}
finally
{if (conn != null){conn.Close();}}
}
public int GetNumberOfRecords()
{
int count = -1;
try
{ conn.Open();
SqlCommand cmd = new SqlCommand(“select count(*) from Produse”, conn);
count = (int)cmd.ExecuteScalar();
}
finally
}
return count;
}
}
6.5. DataReader
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 aplicaþia curentã (sub forma unui obiect din categoria
DataSet).
Clasele DataReader permit parcurgerea într-un singur sens a sursei de date, fãrã
posibilitate de modificare a datelor la sursã. Dacã se doreºte modificarea datelor la
sursã, se va utiliza ansamblul DataAdapter + DataSet.
Datorita faptului cã citeºte doar înainte (forward-only) permite acestui tip de date
sã fie foarte rapid în citire. Overhead-ul asociat este foarte mic (overhead generat cu
inspectarea rezultatului ºi a scrierii în baza de date). Dacã într-o aplicaþie este nevoie
doar de informaþii care vor fi citite o singura datã, sau rezultatul unei interogãri este
prea mare ca sa fie reþinut în memorie (caching) DataReader este soluþia cea mai
bunã.
Un obiect DataReader nu are constructor36, ci se obþine cu ajutorul unui obiect de
tip Command ºi prin apelul metodei ExecuteReader() (vezi exerciþiile de la capitolul
anterior). Evident, pe toatã durata lucrului cu un obiect de tip DataReader, conexi-
unea trebuie sã fie activã. Toate clasele DataReader (SqlDataReader,
OleDbDataReader etc.) implementeazã interfaþa IDataReader.
6.5.1. Proprietãþi:
a) IsClosed (boolean, read-only)- returnezã true dacã obiectul este deschis si fals
altfel
b)HasRows (boolean,read-only) - verificã dacã reader-ul conþine cel puþin o înre-
gistrare
c) Item (indexator de câmpuri)
d)FieldCount - returneazã numãrul de câmpuri din înregistrarea curentã
6.5.2. Metode:
a) Close() închidere obiectului ºi eliberarea resurselor; trebuie sã preceadã
închiderea conexiunii.
b)GetBoolean(), GetByte(), GetChar(), GetDateTime(), GetDecimal(), GetDouble(),
GetFloat(), GetInt16(), GetInt32(), GetInt64(), GetValue(), GetString()
returneazã valoarea unui câmp specificat, din înergistrarea curentã
36 Dacã pentru instantiere este folosit operatorul new veþi obþine un obiect cu care nu puteþi face nimic pentru cã nu
are o conexiune ºi o comandã ataºate.
c) GetBytes(), GetChars() citirea unor octeþi/caractere dintr–un câmp de date binar

d)GetDataTypeName(), GetName() returneazã tipul/numele câmpului specificat
e) IsDBNull() returneazã true dacã în câmpul specificat prin index este o valoare
NULL
f) NextResult()determinã trecerea la urmãtorul rezultat stocat în obiect (vezi exem-
plul)
g)Read() determinã trecerea la urmãtoarea înregistrare, returnând false numai
dacã aceasta nu existã; de reþinut cã iniþial poziþia curentã este înaintea primei
înregistrãri.
DataReader obþine datele într-un stream secvenþial. Pentru a citi aceste informaþii tre-
buie apelatã metoda Read; aceasta citeste un singur rând din tabelul rezultat. Metoda
clasicã de a citi informaþia dintr-un DataReader este de a itera într-o buclã while.
Ex.1)
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 () );
DataReader implementeazã ºi indexatori (în exemplul anterior am afiºat primele

coloane folosind indexatori numerici).
Nu este foarte clar pentru cineva care citeºte codul care sunt coloanele afiºate
decât dacã s-a uitat ºi în baza de date. Din aceasta cauzã este preferatã utilizarea
indexatorilor de tipul string. Valoarea indexului trebuie sã fie numele coloanei din
tabelul rezultat.
Indiferent cã se foloseºte un index numeric sau unul de tipul string indexatorii
întorc totdeauna un obiect de tipul object fiind necesarã conversia.
Exemplu: Codul

while (rdr.Read()) {Console.WriteLine(rdr[0]);}
este echivalent cu

while (rdr.Read()){Console.WriteLine (rdr[“ID_PRODUS”]);
Exerciþiu. Afiºaþi conþinutul tabelei PRODUSE utilizând DataReader.

using System;
using System.Data;
class ADO3
{ static void Main()
{ADO3 rd = new ADO3();
rd.SimpleRead();
}
public void SimpleRead()

{ SqlDataReader rdr = null;
SqlConnection conn = new SqlConnection(
“Data Source=(local);Initial Catalog=MAGAZIN;Integrated Security=SSPI”);
try { conn.Open();
Console.WriteLine(“DENUMIRE PRODUS DESCRIERE”);
while (rdr.Read()){string den = (string)rdr[“DENUMIRE_PRODUS”];
string descr = (string)rdr[“DESCRIERE”];
Console.Write(“{0,-20}”, den);
Console.Write(“{0,-30}”, descr);
Console.WriteLine();
}
}
finally {if (rdr != null){rdr.Close();}
}
}
}
6.6. DataAdapter
Folosirea combinatã a obiectelor DataAdapter ºi DataSet permite operaþii de
selectare, ºtergere, modificare ºi adãugare la baza de date. Clasele DataAdapter
genereazã obiecte care funcþioneazã ca o interfaþã între sursa de date ºi obiectele
DataSet interne aplicaþiei, permiþând prelucrãri pe baza de date. Ele gestioneazã
automat conexiunea cu baza de date astfel încât conexiunea sã se facã numai atunci
când este imperios necesar.
Un obiect DataSet este de fapt un set de tabele relaþionate. Foloseºte serviciile
unui obiect DataAdapter pentru a-ºi procura datele ºi trimite modificãrile înapoi cãtre
baza de date. Datele sunt stocate de un DataSet în format XML, acelaºi folosit ºi pen-
tru transferul datelor.
În exemplul urmãtor se preiau datele din tablele elevi ºi profi:
SqlDataAdapter de=new SqlDataAdapter(“SELECT nume,clasa FROM elevi”, conn);

de.Fill(ds,”Elevi”);//transferã datele în datasetul ds sub forma unei tabele locale
numite elevi
SqlDataAdapter dp=new SqlDataAdapter(“SELECT nume, clasdir FROM profi”,conn);
dp.Fill(ds,”Profi”);//transferã datele în datasetul ds sub forma unei tabele locale

numite profi
a) DeleteCommand, InsertCommand, SelectCommand, UpdateCommand (Command), conþin
comenzile ce se executã pentru selectarea sau modificarea datelor în sursa de
date.
b)MissingSchemaAction (enumerare) determinã ce se face atunci când datele aduse
nu se potrivesc peste schema tablei în care sunt depuse. Poate avea urmãtoarele
valori:
Add - implicit, DataAdapter adaugã coloana la schema tablei
AddWithKey – se adugã coloana ºi informaþii relativ la cheia primarã
Ignore - se ignorã lipsa coloanei respective, ceea ce duce la pierdere de date
Error - se genereazã o excepþie de tipul InvalidOperationException.
6.6.2. Metode
Constructori:SqlDataAdapter()|SqlDataAdapter(obiect_comanda)|
SqlDataAdapter(string_comanda, conexiune);
a) Fill() permite umplerea unei tabele dintr–un obiect DataSet cu date. Permite
specificarea obiectului DataSet în care se depun datele, eventual a numelui
tablei din acest DataSet, numãrul de înregistrare cu care sã se înceapã popu-
larea (prima având indicele 0) ºi numãrul de înregistrãri care urmeazã a fi aduse.
a) Update() permite transmiterea modificãrilor efectuate într–un DataSet cãtre
baza de date.
6.7. DataSet
Un DataSet este format din Tables (colecþie formatã din obiecte de tip DataTable;
DataTable este compus la rândul lui dintr-o colecþie de DataRow ºi DataColumn),
Relations (colecþie de obiecte de tip DataRelation pentru memorarea legãturilor
pãrinte–copil) ºi ExtendedProperties ce conþine proprietãþi definite de utilizator.
Scenariul uzual de lucru cu datele dintr-o tabelã conþine urmãtoarele etape:
• popularea succesivã a unui DataSet prin intermediul unuia sau mai multor
obiecte DataAdapter, apelând metoda Fill (vezi exemplul de mai sus)
• procesarea datelor din DataSet folosind numele tabelelor stabilite la umplere,
ds.Tables[“elevi”], sau indexarea acestora, ds.Tables[0], ds.Tables[1]
• actualizarea datelor prin obiecte comandã corespunzãtoare operaþiilor INSERT,
UPDATE ºi DELETE. Un obiect CommandBuilder poate construi automat o com-
binaþie de comenzi ce reflectã modificãrile efectuate.
Aºadar, DataAdapter deschide o conexiune doar atunci când este nevoie ºi o

inchide imediat aceasta nu mai este necesarã.
De exemplu DataAdapter realizeazã urmãtoarele operaþiuni atunci când trebuie sa

populeze un DataSet:deschide conexiunea, populeaza DataSet-ul,închide conexiunea
ºi urmatoãrele operaþiuni atunci când trebuie sa facã update pe baza de date:
deschide conexiunea, scrie modificarile din DataSet in baza de date,inchide conexi-
unea. Intre operaþiunea de populare a DataSet-ului ºi cea de update conexiunile sunt
inchise. Intre aceste operaþii în DataSet se poate scrie sau citi.
Crearea unui obiect de tipul DataSet se face folosind operatorul new.
Exemplu. DataSet dsProduse = new DataSet ();
Constructorul unui DataSet nu necesitã parametri. Existã totuºi o supraîncãrcare a

acestuia care primeºte ca parametru un string ºi este folosit atunci cand trebuie sã se
facã o serializare a datelor într-un fisier XML. In exemplul anterior avem un DataSet
gol ºi avem nevoie de un DataAdapter pentru a-l popula.
Un obiect DataAdapter conþine mai multe obiecte Command (pentru inserare,
update, delete ºi select) ºi un obiect Connection pentru a citi ºi scrie date.
În exemplul urmãtor construim un obiect de tipul DataAdapter, daProd. Comanda
SQL specificã cu ce date va fi populat un DataSet, iar conexiunea conn trebuie sã fi
fost creatã anterior, dar nu ºi deschisã. DataAdapter-ul va deschide conexiunea la
apelul metodelor Fill ºi Update.
SqlDataAdapter daProd =
new SqlDataAdapter (“SELECT ID_PRODUS, DENUMIRE_PRODUS FROM PRODUSE”, conn);
Prin intermediul constructorului putem instanþia doar comanda de interogare.

Instanþierea celorlalte se face fie prin intermediul proprietãtilor pe care le expune
DataAdapter, fie folosind obiecte de tipul CommandBuilder.
SqlCommandBuilder cmdBldr = new SqlCommandBuilder (daProd);
La iniþializarea unui CommandBuilder se apleleazã un constructor care primeºte
ca parametru un adapter, pentru care vor fi construite comenzile.
SqlCommandBuilder are nu poate construi decât comenzi simple ºi care se aplicã
unui singur tabel. Atunci cand trebui ca sa facem comenzi care vor folosi mai multe
tabele este recomandatã construirea separatã a comnezilor ºi apoi atasarea lor
adapterului folosind proprietãþi.
Popularea DataSet-ului se face dupã ce am construit cele douã instanþe:
daProd.Fill (dsProduse, “PRODUSE”);
În exemplul urmãtor va fi populat DataSet-ul dsProduse. Cel de-al doilea para-

metru (string) reprezintã numele tabelului (nu numele tabelului din baza de date, ci
al tabelului rezultat în DataSet) care va fi creat. Scopul acestui nume este identificarea
ulterioarã a tabelului. În cazul în care nu sunt specificate numele tabelelor, acestea
vor fi adãugate în DataSet sub numele Table1, Table2, ...
Un DataSet poate fi folosit ca sursã de date pentru un DataGrid din Windows

Forms sau ASP.Net .
Exemplu.
DataGrid dgProduse = new DataGrid();

dgProduse.DataSource = dsProduse;
dgProduse.DataMembers = “PRODUSE”;37
Dupã ce au fost fãcute modificãri într-un DataSet acestea trebuie scrise ºi în baza
de date. Actualizarea se face prin apelul metodei Update.
daProd.Update (dsProduse, “PRODUSE”);
6.8. SqlParameter
Atunci când lucrãm cu bazele de date avem nevoie, de cele mai multe ori sã filtraþi
rezultatul dupã diverse criterii. De obicei acest lucru se face în funcþie de niºte criterii
pe care utilizatorul le specificã (ex: vreþi sã vedeþi doar pãpuºile Barbie).
Cea mai simplã metodã de filtrare a rezultatelor este sã construim dinamic string-ul
SqlCommand dar aceastã metoda nu este recomandatã deoarece poate afecta baza
de date (ex. Accesarea informaþiilor confidenþiale).
Dacã folosim interogãri cu parametri atunci orice valoare pusã într-un parametru
nu va fi tratatã drept cod SQL, ci ca valoare a unui câmp, fãcând aplicaþia mai sigurã.
Pentru a folosi interogãri cu parametri trebuie sã:
a) construim string-ul pentru SqlCommand folosind parametri;
Ex. SqlCommand cmd =

new SqlCommand(“SELECT * FROM PRODUSE WHERE DENUMIRE = @den”, conn);38
b)construim un obiect SqlParameter asignând valorile corespunzãtoare;
Ex. SqlParameter param = new SqlParameter();

param.ParameterName = “@Cden”;
param.Value = sir;
c) adãugaþi obiectul SqlParameter la obiectul SqlCommand, folosind proprietatea

Parameters.
Ex. cmd.Parameters.Add(param);
37 Se pot afiºa mai multe tabele dintr-un DataSet, semnul "+" permiþându-i utilizatorului sã aleaga care tabel sã fie
afiºat. Pentru a suprima afiºarea acelui semn "+" setãm proprietatea DataMembers pe numele tabelului care va fi
afiºat. Numele tabelului este acelaºi care l-am folosit ca parametru în apelul metodei Fill.
38 Atunci când comanda va fi executatã @den va fi înlocuit cu valoarea aflatã în obiectul SqlParameter ataºat. Dacã
nu asociem o instanþã de tipul SqlParameter pentru un parametru din string-ul de interogare sau avem mai multe
instanþe SqlParameter pentru un parametru vom obþine o eroare la rulare
6.9. Proceduri Stocate (Stored Procedures)

O procedurã stocatã este o secvenþã de instrucþiuni SQL, salvatã în baza de date,
care poate fi apelatã de aplicaþii diferite. Sql Server compileazã procedurile stocate,
ceea ce creºte eficienþa utilizãrii lor. De asemenea, procedurile stocate pot avea para-
metri.
O procedurã stocatã poate fi apelatã folosind obiectul SqlCommand:
SqlCommand cmd = new SqlCommand(“StoredProcedure1”, conn);

cmd.CommandType = CommandType.StoredProcedure; //Tipul obiectului comanda este pro-
cedura stocata
Primul parametru al constructorului este un ºir de caractere ce reprezintã numele

procedurii stocate. A doua instrucþiune de mai sus spune obiectului SqlCommand ce
tip de comandã va fi executatã, prin intermediul proprietãþii CommandType.
Exemplu:
SqlCommand cmd = new SqlCommand(“StoredProcedure1”, conn);

cmd.CommandType = CommandType.StoredProcedure; //Tipul obiectului coman-
da este procedura stocata
personDs = new DataSet();

personDa = new SqlDataAdapter(“”, conn);
personDa.SelectCommand = cmd;
personDa.Fill(personDs, “PersonTable”);
Apelul procedurilor stocate, parametrizate, este asemãnator cu cel al interogãrilor

cu parametri.
//Obiect Comanda, in care primul parametru este numele procedurii stocate

SqlCommand cmd = new SqlCommand(“City”, conn);
cmd.CommandType = CommandType.StoredProcedure; //Tipul obiectului coman-
da este procedura stocata
cmd.Parameters.Add(new SqlParameter(“@City”, inputCity));
personDs = new DataSet();

personDa = new SqlDataAdapter(“”, conn);
personDa.SelectCommand = cmd;
personDa.Fill(personDs, “PersonTable”);
Primul argument al constructorului obiectului SqlCommand este numele proce-

durii stocate. Aceastã procedurã are un parametru numit @City. De aceea trebuie
folosit un obiect de tip SqlParameter pentru a adauga acest parametru la obiectul de
tip Command.
Exerciþiu de sintezã. Construiþi o aplicaþie pentru a simula gestiunea unei bibliote-
ci ºcolare.
Precizãri.Toate informaþiile se vor afla într-o bazã de date. Creati propriile structuri
de date adecvate rezolvarii problemei. Utilizati Microsoft Access pentru crearea bazei
de date. Iniþial aplicaþia va afiºa o formã Windows care permite selectarea operaþiei
efectuate (adãugare carte/cãrþi, adãugare abonat, actualizare stare carte/cãrþi/abonat,
împrumutã carte/cãrþi, etc.)
6.11. Proiectarea vizualã a seturilor de date

Mediul de dezvoltare Visual Studio dispune de instrumente puternice ºi sugestive
pentru utilizarea bazelor de date în aplicaþii. Conceptual, în spatele unei ferestre în
care lucrãm cu date preluate dintr-una sau mai multe tabele ale unei baze de date se
aflã obiectele din categoriile Connection, Command, DataAdapter ºi DataSet prezen-
tate. ”La vedere” se aflã controale de tip DataGridView, sau TableGridView,
BindingNavigator etc.
Meniul Data ºi fereastra auxiliarã Data Sources ne sunt foarte utile în lucrul cu
surse de date externe.
Sã urmãrim un scenariu de realizare a unei aplicaþii simple cu o fereastrã în care putem

vizualiza date dintr-o tabelã, putem naviga, putem modifica sau ºterge înregistrãri.
• Iniþiem adãugarea unei surse de date (Add New Source)
• Configurãm cu atenþie (asistaþi de ”vrãjitor”) conexiunea cu o sursã de tip SQL
sau Access; figura surprinde elemente de conectare la o bazã de date Access,
numitã Authors, bazã stocatã pe hard-discul local.
• Selectãm tabelele care ne intereseazã din baza de date ºi câmpurile din cadrul
tabelei ce vor fi reþinute în TableAdapter (din categoria DataAdapter)
• Când operaþiunea se încheie, date relative la baza de date la care ne-am

conectat sunt integrate în proiect ºi pictograma, ca ºi structura bazei de date,
apar în fereastra Data Source
• Prin “tragerea” unor obiecte din fereastra Data Sources în fereastra noastrã
nouã, se creeazã automat obiecte specifice. În partea de jos a figurii se pot
observa obiectele de tip Dataset, TableAdapter, BindingSource,
BindingNavigator ºi, în fereastrã, TableGridView
BindingNavigator este un tip ce permite, prin instanþiere, construirea barei de na-

vigare care faciliteazã operaþii de deplasare, editare, ºtergere ºi adãugare în tabel.
Sã observãm cã reprezentarea vizualã a fiecãrui obiect este înzestratã cu o sãgetã
în partea de sus, în dreapta. Un clic pe aceastã sãgeatã activeazã un meniu contextu-
al cu lista principalelor operaþii ce se pot efectua cu obiectul respectiv.
Meniul contextual asociat grilei în care vor fi vizualizate datele permite configu-
rarea modului de lucru cu grila (sursa de date, operaþiile permise ºi altele).
În timpul rulãrii aplicaþiei, bara de navigare ºi elementele vizuale ale grilei permit
operaþiile de bazã cu înregistrãrile bazei de date. Operaþiile care modificã baza de
date trebuie sã fie definitivate prin salvarea noilor date .
109
CAPITOLUL 7
39
MiniGhid Metodologic
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 cãtre.
Programa ºcolarã descrie oferta educaþionalã a unei anumite discipline pentru un
parcurs ºcolar determinat Filosofia contemporanã a educaþiei a evidenþiat diferenþa
dintre o educaþie bazatã pe curriculum, adicã având ca element central la toate eta-
jele sale activiatea de proiectare ºi programa analiticã, care are în centrul activitãþii
didactice ideea de programare a traseului elevului cãtre un þel cunoscut ºi impus doar
de cãtre adulþi.
Conceptual, programele ºcolare actuale, se diferenþiazã de ,,programele analitice”
prin accentul pe care îl pun pe interiorizarea unui mod de gândire specific fiecãrui
domeniu transpus în ºcoalã prin intermediul unui obiect de studiu, nu pe succesiunea
conþinuturilor ºi pe numãrul de ore alocat lor.
Actualele programe ºcolare subliniazã importanþa rolului reglator al achiziþiilor
elevilor în plan formativ. Centrarea pe competenþe reprezintã modalitatea care face
ca sintagma centrarea pe elev sã nu rãmânã o lozincã fãrã conþinut.
Proiectarea curriculumului pe competenþe vine în întâmpinarea cercetãrilor din psi-
hologia cognitivã, conform cãrora prin competenþã se realizeazã în mod exemplar tran-
ferul ºi mobilizarea cunoºtinþelor ºi a depriderilor în situaþii/contexte noi ºi dinamice.
Modelul de proiectare curricularã centrat pe competenþe simplificã structura cu-
rriculumului ºi asigurã o mai mare eficienþã a proceselor de predare/învãþare ºi eva-
luare. Acesta permite operarea la toate nivelurile cu aceeaºi unitate: competenþa, în
mãsurã sã orienteze demersurile agenþilor implicaþi în procesul de educaþie:
• conceptorii de curriculum;
• specialiºtii în evaluare;
• profesorii;
• inspectorii;
• eleviii;
• pãrinþii.
39 În realizarea minighidului metodologic baza de documentare a constituit-o un set de lucrãri bibliografice, cãrora li
s-au operat simplificãri, actualizãri, particularizãri ºi recomandãri, corelate cu curriculumul ºcolar în vigoare, în sco-
pul operaþionalizãrii informaþiilor."
Fãrã a intra în detalii conceptuale, formulãm câteva definiþii de lucru necesare pen-
tru explicarea manierei în care au fost concepute programele ºcolare.
Definim competenþele ca fiind ansambluri structurate de cunoºtinþe ºi deprinderi
dobândite prin învãþare; acestea permit identificarea ºi rezolvarea în contexte diverse
a unor probleme caracteristice unui anumit domeniu.
Structura programei ºcolare cuprinde: o notã de prezentare, competenþe generale,

competenþe specifice ºi conþinuturi, valori ºi atitudini, sugestii metodologice.
♦ Competenþele generale se definesc pe obiect de studiu ºi se formeazã pe dura-
ta învãþãmântului liceal. Ele au un grad ridicat de generalitate ºi complexitate ºi
au rolul de a orienta demersul didactic cãtre achiziþiile finale ale elevului.
♦ Competenþele specifice se definesc pe obiect de studiu ºi se formeazã pe par-
cursul unui an ºcolar. Ele sunt derivate din competenþele generale, fiind etape în
dobândirea acestora. Competenþelor specifice li se asociazã prin programã
unitãþi de conþinut.
Componenta fundamentalã a programei este cea referitoare la competenþe speci-
fice ºi conþinuturi.
Pentru a asigura o marjã cât mai largã de acoperire a obiectelor de studiu, s-a por-
nit de la o diferenþiere cât mai finã a etapelor unui proces de învãþare. Acestora le
corespund categorii de competenþe organizate în jurul câtorva verbe definitorii, ce
exprimã complexe de operaþii mentale:
1. Receptarea - concretizatã prin urmãtoarele concepte operaþionale:
- identificarea de termeni, relaþii, procese;
- observarea unor fenomene, procese;
- perceperea unor relaþii, conexiuni;
- nominalizarea unor concepte;
- culegerea de date din surse variate;
- definirea unor concepte.
2. Prelucrarea primarã (a datelor) - concretizatã prin urmãtoarele concepte operaþionale:
- compararea unor date, stabilirea unor relaþii;
- calcularea unor rezultate parþiale;
- clasificarea datelor;
- reprezentarea unor date;
- sortarea-discriminarea;
- investigarea, descoperirea, explorarea;
- experimentarea.
3. Algoritmizarea - concretizatã prin urmatoarele concepte operaþionale:
- reducerea la o schemã sau model;
- anticiparea unor rezultate;
- remarcarea unor invarianþi;
- reprezentarea datelor
- rezolvarea de probleme prin modelare si algoritmizare.
4. Exprimarea - concretizata prin urmatoarele concepte operaþionale:
- descrierea unor stãri, sisteme, procese, fenomene;
- generarea de idei;
- argumentarea unor enunþuri;
- demonstrarea.
CAPITOLUL 7. MiniGhid Metodologic 111
5. Prelucrarea secundarã (a rezultatelor) - concretizatã prin urmãtoarele concepte

operaþionale:
- compararea unor rezultate, date de ieºire, concluzii;
- calcularea, evaluarea unor rezultate;
- interpretarea rezultatelor;
- analiza de situaþii;
- elaborarea de strategii;
- relaþionãri între diferite tipuri de reprezentãri, între reprezentare ºi obiect.
6. Transferul, care poate fi concretizat prin urmatoarele concepte operaþionale:
- aplicarea în alte domenii;
- generalizarea ºi particularizarea;
- integrarea unor domenii;
- verificarea unor rezultate;
- optimizarea unor rezultate;
- transpunerea într-o altã sferã;
- negocierea;
- realizarea de conexiuni între rezultate;
- adaptarea ºi adecvarea la context.
Competenþele generale ce se urmãresc a fi formate la elevi pe parcursul treptei

liceale de ºcolarizare precum ºi competenþele specifice fiecãrui an de studiu, derivate
din acestea, se stabilesc pornind de la modelul de generare prin gruparea categori-
ilor de concepte operaþionale în funcþie de dominantele avute în vedere.
♦ Valorile ºi atitudinile apar în mod explicit sub forma unei liste separate in progra-
ma fiecãrui obiect de studiu. Ele acoperã întreg parcursul învãþãmantului liceal ºi
orienteazã dimensiunile axioiogicã si afectiv-atitudinalã aferente formãrii perso-
nalitãþii din perspective fiecãrei discipline. Realizarea lor concretã derivã din
activitatea didacticã permanentã a profesorului, constituind un implicit al aces-
teia. Valorile ºi atitudinile au o importanþã egalã în reglarea procesului educativ
ca ºi competenþele - care acoperã dimensiunea cognitivã a personalitãþii - dar se
supun altor criterii de organizare didactico-metodicã ºi de evaluare.
♦ Sugestiile metodologice cuprind recomandãri generale privind metodologia de
aplicare a programei. Aceste recomandãri se pot referi la:
− desfãºurarea efectivã a procesului de predare/învãþare, centrat pe formarea
de competenþe:
− identificarea celor mai adecvate metode ºi activitãþi de învãþare;
− dotãri/materiale necesare pentru aplicarea în condiþii optime a programei;
− evaluarea continuã.
Dincolo de structura unitarã a programelor ºcolare, curriculumul naþional actual

propune o ofertã flexibilã, ce permite profesorului adaptarea cadrului formal la per-
sonalitatea sa ºi la specificul clasei de elevi cu care lucreazã. Elementele care asigurã
acest reglaj sunt:
− posibilitatea intervenþiei profesorului în succesiunea elementelor de conþinut, cu
condiþia asigurãrii coerenþei tematice ºi a respectãrii logicii interne a domeniului;
− lipsa prescrierii de la centru a intervalului de timp alocat elementelor de conþinut;

− posibilitatea modificãrii, a completãrii sau a înlocuirii activitãþilor de învãþare,
astfel încât acestea sã permitã un demers didactic personalizat.
II. Aplicarea programelor ºcolare

Existenþa unor programe centrate pe achiziþiile elevilor determinã un anumit sens
al schimbãrii în didactica fiecãrei discipline. Tabelul de mai jos prezintã în antitezã
caracteristici ale procesului de predare-învãþare din didactica tradiþionala ºi didactica
actualã.
Strategii didactice
Criterii
Orientare tradiþionalã Orientare modernã
Urmãreºte prelegerea, expunerea,
Exprimã puncte de vedere proprii.
explicaþia profesorului.
Încearcã sa reþinã ºi sa reproducã Realizeazã un schimb de idei cu
ideile auzite ceilalþi.
Rolul elevului Argumenteazã; pune ºi îºi pune
Acceptã în mod pasiv ideile
întrebãri cu scopul de a înþelege,
transmise.
de a realiza sensul unor idei
Coopereazã în rezolvarea problemelor
Lucreazã izolat.
ºi a sarcinilor de lucru.
Expune, þine prelegeri. Faciliteazã ºi modereazã învãþarea.
Ajutã elevii sã înþeleagã ºi sã explice
Impune puncte de vedere.
Rolul profesorului punctele de vedere proprii.
Se considerã ºi se manifestã în per-
Este partener în învãþare.
manenþã "ca un pãrinte"'.
Învãþarea are loc predominant prin
Învãþarea are loc predominant prin
memorare ºi reproducere de
formare de competenþe ºi deprinderi
Modul de realizare cunoºtinþe, prin apel doar la exemple
practice.
a învãþãrii "clasice", validate.
Învãþarea conduce la competiþie între Învãþarea se realizeazã prin
elevi, cu scopul de ierarhizare cooperare.
Vizeazã mãsurarea ºi aprecierea
Vizeazã mãsurarea ºi aprecierea
competenþelor (ce poate sã facã
cunoºtinþelor (ce ºtie elevul).
elevul cu ceea ce ºtie).
Evaluarea Pune accent pe aspectul cantitativ Pune accent pe elementele de ordin
(cât de multã informaþie deþine elevul). calitativ (valori, atitudini).
Vizeazã clasificarea "staticã" a Vizeazã progresul în învãþare pentru
elevilor, fiecare elev.
De fapt, diferenþa dintre didactica tradiþionalã ºi cea actualã constã în modul de

concepere ºi organizare a situaþiilor de învãþare (riguros dirijate în primul caz ºi
având autonomie de diferite grade, în cel de-al doilea). Altfel spus, o strategie este
legitimã sau ilegitimã nu în general, ci potrivit unor circumstanþe concrete; profesorul
eficient este acela care ºtie:
− sã selecþioneze
− sã combine
− sã varieze diferite metode
− sã aleagã strategii adecvate.
III. Proiectarea demersului didactic

Predarea reprezintã activitatea profesorului de organizare ºi conducere a ofertelor
de învãþare care are drept scop facilitarea ºi stimularea învãþãrii eficiente la elevi.
Proiectarea demersului didactic este acea activitate desfãºuratã de profesor care
constã în anticiparea etapelor ºi a acþiunilor concrete de realizare a predãrii.
Proiectarea demersului didactic presupune:
− lectura personalizatã a programelor ºcolare;
− planificarea calendaristicã;
− proiectarea secvenþialã (a unitãþilor de învãþare).
III.1. Lectura personalizatã a programelor ºcolare

În contextul noului curriculum, conceptul central al proiectãrii didactice este demer-
sul didactic personalizat, iar instrumentul acestuia este unitatea de învãþare.
Demersul personalizat exprimã dreptul profesorului - ca ºi al autorului de manual -
de a lua decizii asupra modalitãþilor pe care le considerã optime în creºterea calitãþii
procesului de învatamant, respectiv, rãspunderea personalã pentru a asigura elevilor
un parcurs ºcolar individualizat, în funcþie de condiþii ºi cerinþe concrete.
LECTURAREA PROGRAMEI se realizeazã “pe orizontalã” în succesiunea urmãtoare:
Competente Competente Conþinuturi Activitãþi

Generale ¼ Specifice ¼ ¼ de învãþare
III.2. Planificarea calendaristicã

În contextul noului curriculum, planificarea calendaristicã este un document
administrativ care asociazã elemente ale programei cu alocarea de timp consideratã
optimã de cãtre profesor pe parcursul unui an ºcolar.
În elaborarea planificãrilor calendaristice recomandãm parcurgerea urmãtoarelor
etape:
1 Realizarea asocierilor dintre competenþele specifice ºi conþinuturi.
2 Împãrþirea în unitãþi de învãþare.
3 Stabilirea succesiunii de parcurgere a unitãþilor de învãþare.
4 Alocarea timpului considerat necesar pentru fiecare unitate de învãþare, în con-
cordanþã cu competenþele specifice ºi conþinuturile vizate.
Planificãrile pot fi întocmite pornind de la urmãtoarea rubricaþie:
Unitatea ºcolarã………………… Profesor……....……………………..

Disciplina……………………….... Clasa/Nr. ore pe sãpt./ ……….....
Planificare calendaristicã
Anul ºcolar…………..
Unitãþi de Competenþe Nr. de ore

Conþinuturi Sãptãmâna Observatii
învãþare specifice alocate
În acest tabel:
• Unitãþile de învãþare se indicã prin titluri (teme) stabilite de cãtre profesor.
• În rubrica Competenþe specifice se trec simbolurile competenþelor specifice din
programa ºcolarã.
• Conþinuturile selectate sunt cele extrase din lista de continuturi ale programei.
• Numarul de ore alocate se stabileºte de cãtre profesor în funcþie de experienþa
acestuia ºi de nivelul de achiziþii ale elevilor clasei.
Întregul cuprins al planificãrii are valoare orientativã, eventualele modificãri deter-
minate de aplicarea efectivã la clasã putând fi consemnate în rubrica Observaþii.
O planificare anualã corect întocmitã trebuie sã acopere integral programa

ºcolarã la nivel de competenþe specifice ºi conþinuturi.
III.3. Proiectarea unei unitãþi de învãþare

Elementul generator al planificãrii calendaristice este unitatea de învãþare.
O unitate de învãþare reprezintã o structurã didacticã deschisã ºi flexibilã,care are
urmãtoarele caracteristici:
− determinã formarea la elevi a unui comportament specific, generat prin inte-
grarea unor competenþe specifice;
− este unitarã din punct de vedere tematic;
− se desfãºoarã în mod sistematic ºi continuu pe o perioadã de timp;
− se finalizeazã prin evaluare.
Detaliem în continuare elementele esenþiale ale proiectãrii unei unitãþi de învãþare.

Se recomandã utilizarea urmãtorului format:
Unitatea ºcolarã………………… Profesor……....……………………..

Disciplina……………………….... Clasa/Nr. ore pe sãpt./ ……….....
Proiectul unitãþii de învãþare …………………………………..

Nr. de ore alocate ………………..
Competenþe Activitãþi de
Conþinuturi Resurse Evaluare Observatii
specifice învãþare
• Conþinuturi: apar inclusiv detalieri de conþinut necesare în explicitarea anumitor

parcursuri, respectiv în cuplarea lor la baza proprie de cunoaºtere a elevilor.
• În rubrica Competenþe specifice se trec simbolurile competenþelor specifice din
programa ºcolarã
• Activitãþile de învãþare 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 specificãri de timp, de loc, forme de organizare a cla-
sei, material didactic folosit etc.
• În rubrica Evaluare se menþioneazã instrumentele sau modalitaþile de evaluare
aplicate la clasã.
Finalul fiecãrei unitãþi de învãþare presupune Evaluare sumativã.
Deºi denumirea ºi alocarea de timp pentru unitãþile de învãþare se stabilesc la

începutul anului ºcolar prin planificare, este recomandabil ca proiectele unitaþilor de
învãþare sã se completeze ritmic pe parcursul anului, având în avans un interval de
timp optim pentru ca acestea sã reflecte cât mai bine realitatea.
În completarea rubricaþiei, se urmãreºte corelarea elementelor celor cinci coloane.
Practic pe baza indicaþiilor din planificare se fac detalierile pe orizontalã, ordonând
activitãþile în succesiunea derulãrii, raportându-le la competenþe ºi specificând
resursele necesare bunei desfãºurãri a procesului didactic.
Proiectarea unitãþii de învãþare - ca ºi a lecþiei - începe prin parcurgerea schemei
urmãtoare:
În ce scop voi
Ce voi face? Cu ce voi face? Cum voi face? Cât s-a realizat?
face?
Determinarea Stabilirea
Identificarea Selectarea
Analiza resurselor activitãþilor de instrumentelor de
competenþelor conþinuturilor
învãþare evaluare
ConceptuI de unitate de învãþare are rolul sã materializeze conceptul de demers

didactic personalizat, flexibilizâd proiectarea didacticã ºi definind în acest sens pentru
practica didacticã premise mai bine fundamentate din punct de vedere pedagogic.
Identificarea unei unitãþi de învãþare se face prin tema acesteia. Stabilirea temei de
catre profesor pe baza lecturii programei, utilizând surse diverse, este primul pas în
identificarea unitãþilor de învãþare în care va fi împarþitã materia anului ºcolar,
respectiv, în organizarea unui demers didactic personalizat. Temele sunt enunþuri
complexe legate de analiza scopurilor învaþãrii, formulãri fie originale, fie preluate
din lista de conþinuturi a programei sau din manual, formulãri care reflectã din partea
profesorului o înþelegere profundã a scopurilor activitãþii sale, talent pedagogic,
inspiraþie, creativitate, etc.
Activitãþile de învãþare se construiesc prin corelarea competenþelor cu conþinu-
turile ºi presupun orientarea cãtre un anumit scop, redat prin tema activitãþii. În
momentul propunerii lor spre rezolvare elevilor, activitãþile de învãþare vor fi trans-
puse într-o anumitã formã de comunicare inteligibilã nivelului de vârstã.
Într-o abordare pragmaticã, resursele cuprind acele elemente care asigurã cadrul
necesar pentru buna desfãºurare a activitãþilor de învãþare. Astfel, profesorul va
menþiona în aceastã rubricã forme de organizare a clasei (tipuri de interacþiuni ale
resurselor umane), mijloace de învãþãmânt, alocarea de timp, precum ºi orice alte
elemente pe care le considerã utile în derularea scenariului didactic.
În condiþiile noului curriculum, lectura programei ºi a manualelor nu mai este în
mod obligatoriu liniarã. Programa trebuie parcursã în mod necesar de cãtre toþi , dar
ea, ca ºi manualele, se pliazã unei citiri personale ºi adaptate. Asupra conþinuturilor
programei profesorul poate interveni prin regruparea lor sub temele unitãþilor de
învãþare pe care le-a stabilit.
III.4. Proiectarea activitãþii de evaluare se realizeazã concomitent cu proiectarea

demersului de predare/învãþare ºi în deplinã concordanþã cu acesta. Câteva întrebãri
utile în proiectarea instrumentelor de evaluare sunt urmãtoarele:
• Care sunt competenþele din programa ºcolarã, pe care trebuie sã le dobân-

deascã elevii?
• Care sunt performanþele minime, medii ºi superioare pe care le pot atinge ele-
vii, pentru a demonstra cã au atins aceste competenþe?
• Care este specificul colectivului de elevi pentru care îmi propun evaluarea?
• Când º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 cât mai
variate astfel încât evaluarea sã fie cât 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 fiecãruia dintre ei?
PREDICTIVÃ (INIÞIALÃ)
TIPURI
DE FORMATIVÃ (CONTINUÃ)
EVALUARE
SUMATIVÃ (FINALÃ)
• Probe scrise
TRADIÞIONALE • Probe orale
METODE ªI • Probe practice
INSTRUMENTE • Observarea sistematicã a elevilor
DE • Investigaþia
EVALUARE • Proiectul
COMPLEMENTARE • Portofoliul
• Tema pentru acasã
• Tema de lucru în clasã
• Autoevaluarea
Adeseori, evaluarea formativã este înlocuitã cu evaluarea curentã, în accepþiunea

tradiþionalã de “notare ritmicã”, constând în probe stereotipe precum dictãri, calcule,
compuneri, diverse tipuri de exerciþii etc., care sunt apreciate prin note în mod apro-
ximativ, fãrã interes în ceea ce priveºte nivelul cognitiv, afectiv, psihomotor, relaþio-
nal. O astfel de evaluare are în vedere doar unele tipuri de comportamente, de obi-
cei nerelevante pentru personalitatea elevului ºi neglijeazã aspecte importante ca:
gândirea, imaginaþia, atitudinea de responsabilitate, adoptarea unor metode proprii
de lucru, competenþa de comunicare ºi de relaþionare etc.
Ceea ce este generalizat în evaluarea curentã din ºcoli este stocarea în memorie a
abstracþiilor ºi promptitudinea reproducerii acestora. Multe cunoºtinþe ºi capacitãþi
care necesitã evaluare sunt ignorate, deºi sunt, în egalã mãsurã, variabile importante
ale învãþãrii, cum ar fi: atitudinea elevului faþã de învãþare, faþã de disciplina de
studiu, faþã de educator ºi faþã de interrelaþiile din interiorul colectivului de elevi,
modul în care elevul învaþã (sistematic sau sporadic), modul cum abordeazã
cunoºtinþele pentru a rezolva probleme practice, specifice vieþii cotidiene etc.
Focalizatã pe unitatea de învãþare, evaluarea ar trebui sã asigure evidenþierea pro-
gresului înregistrat de elev în raport cu sine însuºi, pe drumul atingerii compe-
tenþelor prevãzute în programã. Este important sã fie evaluatã nu numai cantitatea
de informaþie de care dispune elevul, ci, mai ales, ceea ce poate el sã facã utilizând
ceea ce ºtie sau ceea ce intuieºte.
În acest sens, câteva 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
potenþialului de care dispun elevii ºi conduce la perfecþionarea continuã a stilu-
lui ºi a metodelor proprii de învãþare;
− realizarea unui echilibru dinamic între evaluarea scrisã ºi evaluarea oralã: aceas-
ta din urmã, deºi presupune un volum mare de timp pentru aprecierea tuturor
elevilor ºi blocaje datorate emoþiei sau timiditãþii, prezintã avantaje deosebite,

ca: realizarea interacþiunii elev-profesor, demonstrarea comportamentului
comunicativ ºi de inter-relaþionare a elevului.
− folosirea cu mai mare frecvenþã a metodelor de autoevaluare ºi evaluare prin
consultare în grupuri mici.
În raport cu momentele realizãrii evaluãrii, în proiectul unitãþii de învãþare apar
specificaþii: evaluare iniþialã, formativã sau sumativã.
Fiecare activitate de evaluare a rezultatelor ºcolare trebuie însoþitã în mod siste-
matic de o autoevaluare a procesului pe care profesorul l-a desfãºurat cu toþi elevii
ºi cu fiecare elev. Numai astfel pot fi stabilite modalitãþile prin care poate fi reglatã,
de la o etapã la alta, activitatea de învãþare / formare a elevilor în mod diferenþiat.
III.4.1. Tipuri de itemi
Item = <întrebare> + <formatul acesteia> + <rãspunsul aºteptat>
Teoria ºi practica evaluãrii evidenþiazã mai multe citerii pe baza cãrora pot fi clasifi-
caþi itemii. Unul dintre criteriile cel mai des utilizate este acela al gradului de obiec-
tivitate oferit în corectare. În funcþie de acest criteriu, itemii pot fi clasificaþi în trei
mari categorii:
a. Itemii obiectivi asigurã un grad de obiectivitate ridicat în mãsurarea rezultatelor
ºcolare ºi testeazã un numãr mare de elemente de conþinut într-un interval de
timp relativ scurt. Rãspunsul aºteptat este bine determinat, ca ºi modalitatea de
notare a acestuia.
b. Itemii semiobiectivi permit ca rãspunsul aºteptat sã nu fie totdeauna unic deter-
minat, modalitatea de corectare ºi notare inducând uneori mici diferenþe de la
un corector la altul. Aceºtia testeazã o gamã mai variatã de capacitãþi intelec-
tuale, oferind în acelaºi timp posibilitatea de a utiliza ºi materiale auxiliare în
rezolvarea sarcinilor de lucru propuse.
c. Itemii subiectivi (cu rãspuns deschis) solicitã un rãspuns amplu, permiþând va-
lorificarea capacitãþilor creative ale elevilor. Aceºtia sunt relativ uºor de constru-
it, principala problemã constituind-o modul de elaborare a schemei de notare
astfel încât sã se poatã obþine unitate ºi uniformitate la nivelul corectãrii.
d. Itemi obiectivi
Fie cã este vorba de activitãþi de proiectare ºi programare (Informaticã), fie cã este

vorba de activitãþi de utilizare ºi combinare a instrumentelor informatice (Tehnologia
Informaþiei), lucrul cu calculatorul implicã formulãri standardizate, lipsite de echivoc,
itemii obiectivi ºi cei semiobiectivi repezentând instrumente de evaluare fracvent
aplicate la aceste discipline.
Itemii obiectivi sunt caracterizaþi prin:

♦ structurarea sarcinilor propuse ºi standardizarea formatului lor de prezentare;

♦ corelarea strictã a sarcinilor cu obiectivele de evaluãrii;
♦ capacitatea de a testa un numãr mare de elemente de conþinut într-un timp re-
lativ scurt;
♦ obiectivitate privind aprecierea rãspunsului;
♦ posibilitatea asocierii cu un sistem de notare extrem de simplu: punctajul afe-
rent se acordã integral, se acordã parþial conform unei reguli (formule) de calcul
sau nu se acordã deloc (în funcþie de rãspunsul aºteptat);
♦ rolul secundar pe care îl au de a obiºnui elevul cu formulãri standard, ºtiinþifice,
elemente utile în construirea rãspunsurilor pentru itemii semiobiectivi ºi subiec-
tivi.
a.1. Itemi cu alegere dualã

Alegerea dualã presupune formularea unei cerinþe cu douã variante comple-
mentare de rãspuns (Adevãrat/Fals, Da/Nu, Corect/Incorect etc.).
Se pot verifica prin intermediul itemilor cu alegere dualã:
− cunoºtinþele legate de corectitudinea sintacticã a unor expresii (comenzi,
instrucþiuni, notaþii etc.);
− înþelegerea semnificaþiei unor noþiuni din terminologia de specialitate (denu-
miri, instrumente de prelucrare, metode de rezolvare, proprietãþi etc.)
− recunoaºterea unor explicaþii, definiþii, sau imagini.
Itemii de acest tip se prezintã sub forma unor întrebãri sau enunþuri, efortul elevu-
lui reducându-se la identificarea unui rãspuns din douã posibile. Achiziþiile evaluate
prin itemii cu alegere dualã sunt de regulã rudimentare. Fac excepþie enunþurile care
pun în evidenþã justificãri ale unor proprietãþi, operaþii sau reguli, justificãri care nece-
sitã achiziþii cognitive superioare. Tot în categoria itemilor cu alegere dualã se pot real-
iza cerinþe care necesitã din partea elevului operaþii de anticipare a efectului unei oper-
aþii prin aplicarea unui sistem riguros de cunoºtinþe într-un context nou. Aceºtia sunt
itemii cu cel mai înalt grad de dificultate. Atragem atenþia asupra faptului cã lipsa “fir-
ului roºu“ care pune în evidenþã elementele sistematice întâlnite în utilizarea unui pro-
dus soft (chiar ºi în cazul unui soft de bazã) conduc la un experimentalism accentuat
care împiedicã formarea capacitãþii elevului de a se adapta situaþiilor noi, neexersate.
Factorul de discriminare fiind însã extrem de mic, elevul va putea obþine un rezul-
tat acceptabil la un test format numai din astfel de itemi alegând la întâmplare un
rãspuns dintre cele douã admise pentru fiecare item în parte. De obicei, itemii cu
alegere dualã sunt formulaþi în combinaþie cu itemi subiectivi de tipul “Justificaþi...”,
“Scrieþi varianta corectã...”, “Explicaþi în ce constã eroarea...“ etc. În aceste cazuri, o
parte din punctaj este alocatã justificãrii.
Pentru proiectarea corectã a itemilor cu alegere dualã este necesarã respectarea
urmãtoarelor cerinþe:
♦ formularea clarã a enunþului, fãrã ambiguitãþi sau formulãri incomplete;

dacã se solicitã aprecierea cu ADEVÃRAT/FALS, se vor evita enunþurile foarte
generale;
♦ selectarea unor enunþuri relevante pentru domeniul de cunoaºtere sau categoria

de competenþe testatã (uneori, efortul de a realiza enunþuri fãrã echivoc duce la
elaborarea de itemi nesemnificativi din punct de vedere educaþional sau ºtiinþific);
♦ se va evita utilizarea unor enunþuri negative, acestea conducând la raþionamente
ce folosesc dubla negaþie, inducând un grad înalt de ambiguitate;
♦ se vor evita enunþurile lungi ºi complexe, prin eliminarea elementelor redun-
dante inutile în raport cu ideea enunþului ºi cerinþa itemului; nu se va folosi un
limbaj academic, o terminologie foarte specializatã sau o construcþie lingvisticã
stufoasã ºi greoaie;
♦ se va evita introducerea a douã idei într-un singur enunþ, cu excepþia cazului în
care se doreºte evidenþierea relaþiei dintre acestea;
♦ enunþurile vor fi aproximativ egale ca lungime;
♦ enunþurile adevãrate sau false sã fie aproximativ egale ca numãr, dar nu exact
egale, deoarece acesta ar putea constitui un indiciu dupã care elevul încearcã sã
ghiceascã rãspunsul corect.
a.2. Itemi de tip pereche

Itemii de tip pereche solicitã stabilirea unor corespondenþe între informaþiile dis-
tribuite pe douã coloane. Prima coloanã conþine informaþii de tip enunþ (premise), cea
de-a doua coloanã conþinând informaþii de tip rãspuns. Elevului i se solicitã sã aso-
cieze fiecare enunþ cu un unic rãspuns.
Cele douã coloane sunt precedate de instrucþiuni de asociere în care i se explicã
elevului tehnica de formare a perechilor (sã uneascã printr-o linie, sã rescrie
perechile asociate sau doar elementele lor de identificare etc.) ºi se precizeazã dacã
un rãspuns poate fi folosit la mai mult de un enunþ (dacã funcþia de asociere este
injectivã sau nu), eventual dacã existã rãspunsuri care nu vor fi folosite niciodatã
(dacã funcþia de asociere este surjectivã sau nu).
Se verificã prin intermediul itemilor de tip pereche capacitatea elevului de a stabili
corelaþii între:
− funcþii ºi instrumente;
− simboluri ºi concepte;
− termeni ºi definiþii;
− probleme ºi metode de rezolvare.
Itemii de acest tip permit abordarea unui volum mare de informaþie într-un inter-
val de timp relativ redus. Factorul de discriminare este ceva mai mare decât în cazul
itemilor cu alegere dualã, strategia de asociere “la întâmplare” neconducând decât
în situaþii foarte rare la un rezultat acceptabil privind rezultatul testului.
Pentru proiectarea corectã a itemilor de tip de pereche este necesarã respectarea
♦ utilizarea unui material omogen, dintr-o sferã relativ restrânsã;

♦ utilizarea unui numãr inegal de premise ºi rãspunsuri, astfel încât, dacã elevul
asociazã corect n-1 enunþuri dintre cele n date, sã nu rezulte automat rãspunsul
pentru cel de-al n-lea enunþ;
♦ aranjarea listei de rãspunsuri (mai ales dacã sunt multe) într-o ordine logicã, ast-
fel încât cãutarea rãspunsului în listã sã se realizeze cât mai comod;
♦ aranjarea enunþurilor în listã astfel încât sã nu se poatã intui o regulã de asociere
(referinþele sã fie “încruciºate”);
♦ aranjarea coloanelor astfel încât acestea sã încapã în întregime pe aceeaºi 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
numãr de opþiuni din care elevul trebuie sã aleagã un singur rãspuns numit cheie.
Celelalte rãspunsuri, neconforme cu cerinþa, dar plauzibile poartã numele de distractori.
Se verificã prin intermediul itemilor de tip pereche capacitatea elevului de a identifica:
− definiþii ºi notaþii;
− instrumentul adecvat unei prelucrãri;
− secvenþe de program care realizeazã o anumitã prelucrare;
− expresii cu o valoare datã;
− termeni ºi expresii de specialitate;
− metode de rezolvare ºi tehnici de implementare.
Itemii de acest tip permit abordarea unui volum mare de informaþie într-un interval
de timp relativ redus, oferind posibilitatea evaluãrii unor achiziþii cognitive complexe,
deºi nu pot mãsura 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
decât în cazul celorlalþi itemi obiectivi. Abilitatea profesorului de a elabora distractori
cât mai plauzibili, care sã construiascã toate alternativele posibile de a greºi, contribuie
la reuºita aplicãrii testelor cu alegere multiplã. Erorile comise de elevi oferã profesoru-
lui informaþii suplimentare necesare în autoreglarea procesului de învãþãmânt.
O categorie de itemi cu alegere multiplã solicitã rãspunsul corect, celelalte variante
fiind greºite, în timp ce alþi itemi solicitã cel mai bun rãspuns, pe baza unei discri-
minãri complexe. În aceste cazuri trebuie manifestatã grijã la formularea cerinþei ast-
fel încât criteriul de discriminare a “celui mai bun rãspuns” sã reiasã clar din enunþ.
Pentru proiectarea corectã a itemilor cu alegere multiplã este necesarã respectarea
♦ stabilirea clarã a cerinþei, în concordanþã cu obiectivul de evaluare;

♦ furnizarea tuturor informaþiilor necesare în premisã, eliminându-se materialul
irelevant;
♦ formularea premisei folosind afirmaþii sau întrebãri pozitive;
♦ construirea unor alternative plauzibile, aflate în concordanþã cu premisa;
♦ construirea itemului astfel încât sã existe o singurã alternativã “corectã” sau
“cea mai bunã”;
♦ construirea unor alternative astfel încât distractorii sã fie în mod cert “greºiþi” sau
“mai puþin buni”, iar varianta cheie sã fie în mod cert “corectã” sau “cea mai bunã”;
♦ aranjarea listei de rãspunsuri într-o ordine logicã, astfel încât cãutarea rãspun-
sului în listã sã se realizeze cât mai comod;
♦ construirea ansamblurilor de itemi cu alegere multiplã astfel încât rãspunsurile
sã ocupe poziþii diferite în lista de variante (sã nu fie în mod constant al doilea
rãspuns, de exemplu)
b. Itemi semiobiectivi
Itemii semiobiectivi formeazã o categorie de instrumente de evaluare ce solicitã
construirea parþialã sau totalã a unui rãspuns pe baza unei sarcini definite.
Itemii semiobiectivi sunt caracterizaþi prin:
♦ posibilitatea de a testa o gamã mai largã de capacitãþi intelectuale ºi rezultate

ale învãþãrii;
♦ crearea unor situaþii cognitive de nivel mai ridicat prin solicitarea de elaborare a
rãspunsului ºi nu de alegere a lui dintr-o mulþime prestabilitã, ca în cazul
itemilor obiectivi;
♦ raportarea parþial subiectivã a profesorului în raport cu rãspunsul formulat
(rãspunsul poate fi scris ordonat sau dezordonat, formularea poate fi mai clarã
sau mai neclarã, termenii folosiþi se pot încadra în niºte standarde ºtiinþifice sau
pot fi variante particulare ale acestora etc.)
♦ posibilitatea asocierii unui sistem de notare în care pot sã intervinã situaþii
neprevãzute (rãspunsuri neaºteptate, care comportã raportãri noi la barem).
b.1. Itemi cu rãspuns scurt / de completare

Itemii cu rãspuns scurt solicitã ca elevul sã formuleze un rãspuns scurt sau sã
completeze o afirmaþie astfel încât aceasta sã capete sens sau sã aibã valoare de adevãr.
Se pot verifica prin intermediul itemilor cu rãspuns scurt ºi de completare:
− cunoaºterea unor noþiuni, expresii de specialitate, simboluri, notaþii etc.;
− recunoaºterea ºi nominalizarea unor elemente vizuale specifice unui anumit
mediu de lucru;
− capacitatea de integrare a unor elemente necesare din punct de vedere sintactic
sau semantic într-un context dat;
− schimbarea unor elemente dintr-un context dat astfel încât sã se realizeze o
finalitate precizatã.
Itemii cu rãspuns scurt se prezintã cel mai des sub forma unor întrebãri. Ei solicitã
un rãspuns sub o formã restrânsã (un numãr, un simbol, un cuvânt, o expresie, o
propoziþie sau frazã concisã).
Itemii de completarea se prezintã sub forma unui enunþ, unei afirmaþii incomplete.
Ei solicitã gãsirea cuvîntului sau sintagmei care completeazã ºi dã sens enunþului
respectiv.
Pentru proiectarea corectã a itemilor cu rãspuns scurt / de completare este nece-
sarã respectarea urmãtoarelor cerinþe:
♦ formularea enunþului astfel încât sã admitã un rãspus scurt, exprimat cu precizie;

♦ formularea enunþului astfel încât acesta sã admitã un singur rãspuns corect, pe

cât posibil;
♦ rezervarea unor spaþii pentru rãspuns care sã sugereze numãrul de cuvinte
aºteptate (dacã acest lucru nu reprezintã un indiciu), nu ºi dimensiunea lor;
♦ vizarea unui rãspuns care sã reprezinte o sintezã de cunoºtinþe sau un rezultat al
înþelegerii unei situaþii ºi mai puþin o reproducere a unor informaþii.
b.2. Întrebãri structurate

Întrebãrile structurate solicitã, printr-un sistem de subîntrebãri relative la o temã
comunã, rãspunsuri de tip obiectiv, rãspunsuri scurte sau de completare prin care se
pot evalua cunoºtinþele complexe referitoare la tema respectivã fãrã a solicita elabo-
rarea unui rãspuns deschis (eseu).
Se pot verifica prin intermediul întrebãrilor structurate:
− capacitatea de a urmãri, recunoaºte, adapta ºi construi un algoritm pe o temã
datã sau un program într-un limbaj de programare;
− capacitatea de a realiza din aproape în aproape o prelucrare complexã utilizând
un mediu de lucru informatic.
O întrebare structuratã poate sã conþinã materiale suport ºi informaþii suplimenta-
re ce se adaugã treptat, conferind procesului de evaluare varietate, complexitate ºi
gradualitate. Se pot verifica totodatã cunoºtinþe, dar ºi priceperi ºi deprinderi sporind
gradul de obiectivitate în raport cu itemii cu rãspuns deschis. Subîntrebãrile ce
formeazã itemul permit creºterea progresivã a dificultãþii cerinþelor, dar este reco-
mandat ca subîntrebãrile sã fie independente, adicã rãspunsul la o întrebare sã nu
depindã de rãspunsul la întrebãrile precedente. Proiectarea lor necesitã atenþie, pri-
cepere ºi timp.
Pentru proiectarea corectã a întrebãrilor strucutrate este necesarã respectarea
♦ redactarea subîntrebãrilor astfel încât acestea sã solicite rãspunsuri simple la

început crescând pe parcurs dificultatea acestora;
♦ formularea unor subîntrebãri autoconþinute (al cãror rãspuns corect sã nu
depindã de rãspunsul corect la una dintre întrebãrile precedente;realizarea con-
cordanþei dintre enunþul general (tema întrebãrii) ºi subîntrebãrile formulate.
c. Itemi subiectivi (cu rãspuns deschis)

Itemii subiectivi formeazã o categorie de instrumente de evaluare ce vizeazã cre-
ativitatea elevului, originalitatea ºi caracterul personal al rãspunsului. Deºi sunt
uºor de formulat, itemii subiectivi ridicã probleme privind obiectivitatea evaluãrii.
Itemii subiectivi sunt caracterizaþi prin:
♦ abordare globalã a unei sarcini asociate unui obiectiv ce nu poate fi evaluat prin
intermediul itemilor obiectivi;
♦ crearea unor situaþii cognitive de nivel foarte ridicat prin solicitarea de a realiza
interacþiuni reale ºi complexe între cunoºtinþe, abilitãþi ºi deprinderi;
♦ raportarea subiectivã a profesorului în raport cu rãspunsul formulat;

♦ necesitatea predefinirii unor criterii privind baremul de corectare ºi notare, cri-
terii clare, judicioase ºi puternic anticipative;
♦ posibilitatea, în cazul în care baremul nu a prevãzut toate situaþiile de inter-
pretare ºi construire a rãspunsului, a unor elemente noi (rãspunsuri neaºteptate)
care comportã reanalizarea baremului.
În cazul informaticii ºi tehnologiei informaþiei se pot elabora itemi subiectivi de tip

eseu (structurat sau liber) ºi itemi de tip problemã (care necesitã proiectare, redactare
ºi uneori implementare a rezolvãrii).
c.1. Itemi de tip eseu

Itemii de tip eseu pot fi structuraþi sau liberi. Itemii structuraþi sunt construiþi ast-
fel încât rãspunsul aºteptat sã fie “orientat” cu ajutorul unor elemente din enunþ
(indicii privind ordinea de tratare, numãrul de linii, formularea rãspunsului, ideile
care trebuie sã fie atinse etc.). Un eseu liber nu furnizeazã în enunþ nici un fel de indi-
caþii sau constrângeri, elevul având libertatea sã-ºi strucutreze cum considerã ºi cum
poate materialul pe care-l solicitã enunþul. Acest tip de eseu comportã operaþii de
maximã complexitate (analizã, sintezã, sistematizare ºi restructurare) lãsând frâu
liber fanteziei ºi capacitãþilor creative ale elevului.
Deoarece la informaticã elementele de creativitate se manifestã mai ales prin
rezolvãri de probleme ºi proiecte, iar în cazul tehnologiei informaþiei prin teme prac-
tice ºi proiecte, itemii de tip eseu preferaþi sunt cei structuraþi, un eseu liber nefiind
necesar decât rar, pentru anumite teme cu un volum mai mare de elemente “infor-
mative” în raport cu achiziþiile “operaþionale”.
Se pot verifica prin intermediul itemilor de tip eseu:
− cunoºtinþele globale legate de stuctura sistemelor de calcul, sisteme de operare,
evoluþia istoricã a sitemelor hard ºi soft, principiile de utilizare a unei anumite
aplicaþii, etapele conceptuale ale proiectãrii unei aplicaþii etc.
− capacitãþile de sistematizare a unor elemente prin construirea unor scheme sau
reprezentãri grafice.
Itemii de tip eseu se prezintã sub forma unor cerinþe generale însoþite eventual (pen-
tru eseurile structurate) de indicii privind tratarea cerinþei. Se pot adãuga restricþii
privind întinderea în timp sau spaþiu (numãr rânduri, pagini, paragrafe etc.) sau
privind forma de prezentare a rãspunsului.
c.2. Itemi de tip problemã

Rezolvarea unei probleme presupune soluþionarea unei situaþii conflictuale gene-
ratã de neconcordanþe ivite între sistemul de achiziþii ºi situaþiile concrete descrise de
un enunþ. Aceste neconcordanþe sunt generate uneori de nepotrivirea între contextul
general al cunoºtinþelor ºi situaþiile particulare în care acestea trebuie sã fie aplicate.
Alteori achiziþiile sunt dobândite prin experimente (situaþii particulare) ºi, pentru a fi
aplicate în cu totul alte situaþii, acestea trebuie sã fie ridicate la un înalt nivel de
abstractizare ºi generalizare.
Rezolvarea de probleme este o activitate specificã ºi des utilizatã la disciplina

“Informaticã”, elementele gândirii algoritmice, metodele de rezolvare ºi tehnicile de
implementare fiind supuse unui “tir” sistematic de probleme prin care acestea sã
formeze competenþe reale de programare.
Capacitãþile cognitive superioare legate de aplicare creativã, gândire divergentã,
descoperirea condiþiilor interne, alegerea modelului adecvat etc. sunt verificate prin
itemi de acest tip. Obiectivele urmãrite prin utilizarea rezolvãrii de probleme sunt:
− obþinerea informaþiilor necesare rezolvãrii problemei;
− formularea ºi testarea ipotezelor;
− descrierea metodei de rezolvare a problemei;
− elaborarea unui raport despre rezultatele obþinute;
− posibilitatea de generalizare ºi transfer a tehnicilor de rezolvare.
Cerinþe suplimentare asociate unei probleme pot pune în evidenþã capacitatea ele-
vului de a estima eficienþa unei rezolvãri, de a construi un algoritm conform unor cri-
terii (limita de memorie, numãr de instrucþiuni etc.).
Se pot formula probleme în care se furnizeazã algoritmul ºi se cere un enunþ de
problemã care se rezolvã prin intermediul algoritmului respectiv. Acest tip de item
impune o analizã atentã a algoritmului ºi asocierea lui cu una dintre problemele sau
prelucrãrile numerice întâlnite la matematicã, fizicã sau în alte domenii, o formulare
a enunþului care sã se caracterizeze prin coerenþã.
Enunþurile pot fi formulate abstract, “la obiect” sau pot crea un “context” care tre-
buie modelat pentru a se ajunge la rezolvarea propriu-zisã. “Povestea” în spatele
cãreia se ascunde problema are de cele mai multe ori conotaþii practice, descriind
situaþii concrete de prelucrare, amintind cã rolul programatorului este acela de a
“ordona” iniþial informaþia ºi operaþiile specifice unui anumit context ºi abia dupã
aceea de a elabora algoritmul, de a implementa ºi verifica programul corespunzãtor.
Aspecte de aceeaºi naturã se întâlnesc ºi în domeniul utilizãrii calculatorului, la
Tehnologia informaþiei, când beneficiarul formuleazã un enunþ ºi utilizatorul trebuie
sã-ºi aleagã programul de aplicaþie adecvat, din cadrul programului sã-ºi aleagã
obiectele ºi instrumentele potrivite, sã proiecteze, pe paºi, prelucrarea astfel încât
“produsul” (documentul, prezentarea, raportul etc.) sã rãspundã cerinþelor ºi sã fie
realizat în timp record. Aspectele reale de concepþie, de creativitate ºi gândire diver-
gentã intervin la realizarea machetelor, a prezentãrilor etc.
Evaluarea prin rezolvare de probleme la informaticã ridicã uneori probleme din
punctul de vedere al întocmirii baremului de corectare. Unele tendinþe exagerate tind
sã impunã o corectare pe principiul: problemã=program funcþional corect (pornind
de la premisa cã “un program care aproape merge e ca un avion care aproape
zboarã”). Se recomandã totuºi ca baremul de corectare sã cuprindã fracþiuni din
punctaj pentru diferitele aspecte pe care le comportã rezolvarea unei probleme la
informaticã: corectitudinea sintacticã, structurarea datelor ºi declararea variabilelor,
structurarea programului, corectitudinea algoritmului, eficienþa algoritmului, tratarea
unor situaþii limitã, eventual explicarea metodei aplicate (chiar daca a fost aplicatã
greºit) etc.
Se pot verifica prin intermediul itemilor de rezolvare de probleme:

− concepþia unor algoritmi de rezolvare a problemelor elementare;
− asimilarea unui algoritm general prin adaptarea lui astfel încât sã rezolve o pro-
blemã particularã;
− capacitatea de a alege structurile de program ºi de date adecvate rezolvãrii unei
probleme;
− abilitatea de a implementa programul, de a-l depana, de a-l testa ºi, în funcþie de
erorile apãrute, de a reconsidera elementele de sintaxã ale programului, strate-
giile de structurare a datelor sau însuºi algoritmul de rezolvare (în partea prac-
ticã a probei);
− capacitatea de a organiza volume mari de date cu ajutorul bazelor de date;
− discernãmântul în a alege un algoritm mai eficient (conform unuia dintre din cri-
teriile studiate: numãr operaþii, spaþiu de memorie utilizat)
III.4.2. Metode complementare de evaluare

Metodele complementare de evaluare reprezintã instrumente suplimentare, ne-
standardizate, de evaluare dispunând de forme specifice cum ar fi: investigaþia, referatul,
portofoliul, proiectul, observarea sistematicã a activitãþii elevului ºi autoevaluarea.
Metodele complementare realizeazã actul evaluãrii în strînsã legãturã cu procesul
educativ, prin întrepãtrundere cu etapele acestuia, urmãrind în special capacitãþile
cognitive superioare, motivaþiile ºi atitudinea elevului în demersul educaþional.
Metodele alternative de evaluare se caracterizeazã prin urmãtoarele:
♦ capacitatea de a transforma relaþia profesor-elev inducând un climat de colabo-

rare ºi parteneriat;
♦ posibilitatea transformãrii procesului de evaluare prin înlocuirea tendinþei de a
corecta ºi sancþiona prin aceea de a soluþiona erorile semnalate;
♦ posibilitatea de a deprinde elevul cu mecanismele de aurocorectare ºi autoedu-
care necesare ºi în procesul de integrare socialã;
♦ utilizarea mai amplã a tehnicilor ºi mijloacelor didactice;
♦ caracterul sumativ, realizat prin evaluarea cunoºtinþelor, capacitãþilor ºi atitu-
dinilor pe o periadã mai lungã de timp ºi dintr-o arie mai largã;
♦ caracterul formativ, realizat prin valorificarea atitudinii elevului în raport cu pro-
pria sa evaluare;
♦ capacitatea de a realiza o evaluare individualizatã (observare sistematicã);
♦ capacitatea de a educa spiritul de echipã prin activitãþi de grup (investigaþii,
proiecte);
♦ caracterul profund integrator realizat prin interdisciplinaritate, educare ºi instru-
ire mutilateralã.
1. Investigaþia
Investigaþia este o metodã de evaluare ºi învãþare utilizatã foarte des la disciplina
Tehnologie informaþiei ºi numai ocazional la disciplina Informaticã.
Organizarea unei activitãþi de evaluare ºi învãþare prin metoda investigaþiei presupune:

− valorificarea metodei de învãþare prin descoperire;
− studiul unor documentaþii complementare, experimentarea unor instrumente de
prelucrare nestandard, compararea ºi generalizarea unor tehnici ºi metode uti-
lizate în tehnologie prin cercetarea altor izvoare sau prin utilizarea altor instru-
mente echivalente;
− extrapolarea cunoºtinþelor dobândite ºi verificarea ipotezelor formulate;
− solicitarea unor cunoºtinþe sau deprinderi dobândite la alte dicipline prin
adaptarea creatoare a acestora la cerinþele temei de investigaþie.
În cele mai multe dintre cazuri investigaþia trebuie sã fie organizatã ca muncã inde-
pendentã depusã de elev, dirijatã ºi sprijinitã de profesor. Tehnologia informaþiei, cu
multitudinea de aplicaþii software din domenii atât de variate, este un teren ideal pen-
tru desfãºurarea investigaþiilor. Elevul cerceteazã “posibilitãþile” unei aplicaþii (de
exemplu, aplicaþia româneascã de tip agendã MyCount difuzatã pe Internet): citeºte
explicaþiile asociate butoanelor, opþiunile din meniuri, informaþiile din Help, experi-
menteazã operaþiile propuse de aplicaþie imaginând utilitatea practicã a acestora ºi
formuleazã concluzii generale referitoare la acel soft (utilitate, spaþiul ocupat pe disc
sau în memorie, spaþiul ocupat de produsele construite cu ajutorul lui, calitatea
graficã ºi funcþionalã a interfeþei). Investigaþii mai rafinate pot realiza elevii iniþiaþi î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 activitãþilor de investigaþie, profesorul va urmãri:
♦ formularea generalã a temei;

♦ asigurarea surselor bibliografice sau tehnice necesare;
♦ formularea unor indicaþii care sã direcþioneze activitatea elevilor;
♦ urmãrirea activitãþii elevului în sensul utilizãrii eficiente ºi creatoare a materialu-
lui de investigat;
♦ sprijinirea elevilor sau grupurilor de elevi care întâmpinã dificultãþi în
înþelegerea temei sau a metodelor specifice de studiu;
♦ încurajarea ºi evidenþierea activitãþilor creatoare desfãºurate de elevi, a
descoperirilor neaºteptate.
2. Referatul ºi proiectul
Referatul reprezintã o formã de îmbinare a studiului individual cu activitate de
prezentare ºi argumentare. Tema referatului, însoþitã de bibliografie ºi alte surse de
documentare (Internet, vizite etc.), este tratatã în mod independent de cãtre elev ºi
susþinutã apoi în faþa colegilor sau altui auditoriu mai larg. Varietatea universului
informatic (a limbajelor ºi tehnicilor de programare, a aplicaþiilor din domeniul TIC, a
noutãþilor hardware etc.) justificã utilizarea acestei forme de studiu ºi evaluare la
clasã, atât la Tehnologia informaþiei cât ºi la Informaticã. Dacã studiul aferent ºi rezul-
tatul studiului prezintã interes ºi din punct de vedre practic, rezultatul fiind un pro-
gram (o aplicaþie) sau un produs TI complex (rezultatul aplicãrii creatoare a instru-
mentelor informatice), dacã bibliografia propusã este mai bogatã ºi etapele de

proiectare (concepþie), implementare ºi testare necesitã un timp mai îndelungat,
lucrarea poartã numele de proiect.
Organizarea unei activitãþi de evaluare ºi învãþare prin intermediul referatelor ºi
proiectelor presupune:
− valorificarea metodei de învãþare prin descoperire;
− studiul unor materiale suplimentare ºi izvoare de informare diverse în scopul
îmbogãþirii ºi activizãrii cunoºtinþelor din domeniul studiat sau domenii conexe,
prin completãri de conþinut ale programei sau prin aducerea în atenþie a unei
problematici complet noi;
− structurarea informaþiei corespunzãtoare unui referat într-un material ce poate fi
scris, ilustrat sau prezentat pe calculator; activitãþile de concepere, organizare,
experimentare, reproiectare (dacã este cazul), dezvoltare ºi elaborare a docu-
mentaþiei aferente necesitã planificarea unor etape de elaborare ºi o strategie de
lucru, în cazul proiectului;
− prezentarea referatului sau proiectului de cãtre elevul sau elevii care l-au elabo-
rat, acesta (sau un reprezentant al grupului) trebuind sã-l susþinã, sã fie capabil
sã dea explicaþii suplimentare, sã rãspundã la întrebãri etc.
Referatul este de regulã o lucrarea de mai micã amploare, dar mai structuratã ºi
mai bogatã în informaþii decât o temã de muncã independentã aferentã lecþiei
curente. Proiectul este o lucrare mai amplã a cãrei temã este comunicatã sau aleasã
din timp, elaborarea unui proiect putând sã dureze de la 1-2 sãptãmîni pânã la 2-3
luni sau chiar un semestru. Proiectul poate fi elaborat în grup, cu o distribuire judi-
cioasã a sarcinilor între membrii grupului.
Referatul poate fi utilizat la Informaticã ºi în egalã mãsurã la Tehnologia infor-
maþiei temele referatelor vizând cel mai des domenii de actualitate în producþia
sofware sau în domeniul TIC.
Pentru a realiza o evaluare pe bazã de referate, profesorul:
♦ va formula teme clare, de complexitate medie, precizînd pe cât posibil

amploarea lucrãrii (câte pagini, durata maximã necesarã prezentãrii etc.)
♦ va recomanda sau asigura sursele bibliografice ºi de informare necesare;
♦ îºi va rezerva suficient timp (în perioada de evaluare sau la sfârºitul unor unitãþi
de învãþare) pentru ca elevii însãrcinaþi cu elaborarea referatelor sã-ºi poatã
prezenta referatul;
♦ va supraveghea discuþiile purtate cu elevii asupra conþinutului referatului.
Pentru a realiza o evaluare pe bazã de proiecte, profesorul:
♦ va formula teme practice, de complexitate sporitã, lãsând celor care elaboreazã

proiectul multã libertate în a improviza, adapta ºi interpreta cerinþa într-un mod
personal;
♦ va stabili un termen final ºi, în funcþie de modul de evaluare, termene interme-
diare de raportare;
♦ va recomanda sau asigura sursele bibliografice ºi de informare necesare;

♦ îºi va rezerva suficient timp (în perioada de evaluare sau la sfîrºitul unor unitãþi
de învãþare) pentru ca elevii însãrcinaþi cu elaborarea proiectelor sã-ºi poatã
prezenta rezultatul proiectãrii;
♦ va supraveghea discuþiile purtate cu elevii asupra proiectului.
3. Portofoliul
Portofoliul reprezintã o metodã complexã de evaluare în care un rezultat al eva-
luãrii este elaborat pe baza aplicãrii unui ansamblu variat de probe ºi instrumente de
evaluare.
Prin multitudinea de forme ºi momente în care se desfãºoarã testarea elevului,
rezultatul final “converge” cãtre valoarea realã a acestuia, sesizând elementele de
progres sau regres, ilustrând preocuparea pentru lãmurirea neclaritãþilor, oferind o
imagine de ansamblu asupra nivelului cunoºtinþelor, gradului de formare a abi-
litãþilor ºi gradului de raportare atitudinalã pe care acesta o are faþã de tema evalu-
atã. Portofoliul este realizat pe o periadã mai îndelungatã, de la un semestru, un an,
pânã la un ciclu de învãþãmânt.
Conþinutul unui portofoliu este reprezentat de rezultatele la: lucrãri scrise sau prac-
tice, teme pentru acasã, investigaþii, referate ºi proiecte, observarea sistematicã la
clasã, autoevaluarea elevului, chestionare de atitudini etc. La Tehnologia informaþiei
portofoliul se poate constitui dintr-o colecþie de lucrãri practice realizate pe calcula-
tor, fiecare vizând anumite aspecte de utilizare.
Alegerea elementelor ce formeazã portofoliul este realizatã de cãtre profesor (astfel
încât acestea sã ofere informaþii concludente privind pregãtirea, evoluþia, atitudinea
elevului) sau chiar de cãtre elev (pe considerente de performanþã, preferinþe etc.)
Structurarea evaluãrii sub forma de portofoliu se dovedeºte deosebit de utilã, atât
pentru profesor, cât ºi pentru elev sau pãrinþii acestuia.
Pentru a realiza o evaluare pe bazã de potofoliu, profesorul:
♦ va comunica elevilor intenþia de a realiza un portofoliu, adaptând instrumentele

de evaluare ce constituie “centrul de greutate” ale portofoliului la specificul dis-
ciplinei;
♦ va alege componentele ce formeazã portofoliul, dând ºi elevului posibilitatea de
a adãuga piese pe care le considerã relevante pentru activitatea sa;
♦ va evalua separat fiecare piesã a portofoliului în momentul realizãrii ei, dar va
asigura ºi un sistem de criterii pe baza cãrora sã realizeze evaluarea globalã ºi
finalã a portofoliului;
♦ va pune în evidenþã evoluþia elevului, particularitãþile de exprimare ºi de
raportare a acestuia la aria vizatã;
♦ va integra rezultatul evaluãrii portofoliului în sistemul general de notare.
4. Observarea sistematicã a activitãþii ºi comportamentului elevilor

Fiºa de observare a activitãþii ºi comportamentului elevului înregistreazã infor-
maþii legate de particularitãþile personalitãþii elevului manifestate în procesul didac-
tic, de achiziþiile evaluate spontan (rãspunsuri sporadice, atitudini semnificative etc.),

de progresul înregistrat de acesta. Profesorul construieºte aceastã fiºã în vederea
individualizãrii procesului sumativ de evaluare, dar ºi a celui de învãþare.
Pe baza fiºei de evaluare se poate realiza ºi orientarea ºcolarã ºi profesionalã a ele-
vului. Informaþiile din fiºa personalã au caracter parþial secret, parte dintre ele fiind
comunicate elevului ºi pãrinþilor acestuia.
Un model orientativ de fiºã de observare conþine:
♦ Date generale despre elev (nume, prenume, vârstã, climat educativ, condiþii
materiale, particularitãþi socio-comportamentale);
♦ Particularitãþi ale proceselor intelectuale (gîndire, limbaj, imaginaþie, memorie,
atenþie, spirit de observaþie etc.);
♦ Aptitudini ºi interese manifestate;
♦ Particularitãþi afectiv-motivaþionale;
♦ Trãsãturi de temperament;
♦ Atitudini ºi relaþionare (cu sine însuºi, cu materia studiatã, cu colegii)
♦ Consideraþii privind evoluþia aptitudinilor, atitudinilor, intereselor ºi nivelului de
integrare.
Prin stabilirea copmpetenþelor generale ale disciplinei ºi achiziþiile cognitive ºi com-

portamentale vizate de aceasta, fiºa de observare poate sã conþinã ºi considerente
legate de atingerea ºi formarea competenþelor specifice. Completarea fiºei se rea-
lizeazã în timp într-un ritm adecvat specificului activitãþilor de la disciplina, din anul ºi
de la clasa respectivã, dar ºi în funcþie de implicarea ºi de ritmul individual al elevului.
IV. Proiectul unitãþii de învãþare - Proiectul de lecþie?

Faþã de proiectarea tradiþionalã centratã pe lecþie (ora de curs) - proiectarea unitãþii
de învãþare are urmatoarele avantaje:
• creeazã un mediu de învãþare coerent în care aºteptãrile 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 explo-
rare ºi reflecþie;
• implicã profesorul într-un ,,proiect didactic” pe termen mediu ºi lung, cu accent
pe ritmurile de învãþare proprii ale elevilor;
• dã perspectiva lecþiilor, conferind acestora o structurã specificã, în funcþie de
secvenþa unitãþii de învãþare în care se aflã.
Proiectul de lecþie - conceput ca document separat - este recunoscut ca o formali-
tate consumatoare de timp ºi energie. Proiectul unei unitãþi de învãþare conþine sufi-
ciente elemente pentru a oferi o imagine asupra fiecãrei ore. Ca urmare, în tabelul
care sintetizeaza proiectarea unitatii de învãþare se pot delimita prin linii orizontale
(punctate) spaþiile corespunzatoare unei ore de curs. Astfel, pentru fiecare lecþie,
proiectul unitãþii de învãþare oferã date referitoare la elementele de conþinut ºi com-
petenþele vizate, la care se raporteazã anumite activitãþi de învãþare; totodatã, sunt

indicate resurse materiale, forme de organizare a clasei etc., pentru fiecare activitate
precum ºi instrumente de evaluare necesare la nivelul lecþiei (orei). In consecinþã,
dacã proiectul unitãþii de învãþare este bine construit, nu mai este necesarã detalierea
la nivelul proiectului de lecþie.
Lecþia este înþeleasã ca o componentã operaþionalã (Cum?) pe termen scurt a
unitãþii de învãþare. Dacã unitatea de învãþare oferã întelegerea procesului din per-
spectivã strategicã, lecþia oferã înþelegerea procesului din perspectiva operativã, tac-
ticã. Proiectul unitãþii de învãþare trebuie sã ofere o derivare simplã a lecþiilor compo-
nente. Ca urmare, trecerea de la unitatea de învãþare - o entitate supraordonatã - la o
lecþie componentã trebuie sã permitã o ,,replicare” în acelaºi timp functionalã (De
ce?), structuralã (Cu ce?) ºi operaþionalã (Cum?) a unitaþii de învãþare, la o scarã tem-
poralã mai micã ºi într-un mod subordonat.
Acest mod de tratare orientatã cãtre scopuri precise caracterizeazã organizarea
atât a unitãþii de învãþare cât ºi a lecþiei.
V. Curriculum la decizia ºcolii – CDª

CDª – ul cuprinde orele alocate pentru dezvoltarea ofertei curriculare proprii
fiecãrei unitãþi de învãþãmânt.
Planurile - cadru de învãþãmânt pentru ciclul superior al liceului, filierele teoreticã
ºi vocaþionalã, prevãd la toate profilurile ºi specializãrile, un numãr minim ºi un
numãr maxim de ore pe sãptãmânã pentru CDª.
Schemele orare ale tuturor claselor vor cuprinde, în mod obligatoriu, la toate pro-
filurile ºi specializãrile, cel puþin numãrul minim de ore pe sãptãmânã prevãzut pen-
tru CDª în planul-cadru.
Tipuri de CDª în învãþãmântul liceal
Reglementãrile în vigoare menþioneazã urmãtoarele tipuri de opþionale:
1 de aprofundare
2 de extindere
3 ca disciplinã nouã
4 integrat - la nivelul uneia sau mai multor arii curriculare
5 ca disciplinã care apare în trunchiul comun la alte specializãri
1 Opþionalul de aprofundare este derivat dintr-o disciplinã studiatã în trunchiul
comun, care urmãreºte aprofundarea competenþelor din curriculumul nucleu
prin noi unitãþi de conþinut.
2 Opþionalul de extindere este derivat dintr-o disciplinã studiatã în trunchiul
comun, care urmãreºte extinderea competenþelor generale din curriculumul
nucleu prin noi competenþe specifice ºi noi conþinuturi.
3 Opþionalul ca disciplinã nouã introduce noi obiecte de studiu, în afara celor pre-
vãzute în trunchiul comun la un anumit profil ºi specializare, sau teme noi care
nu se regãsesc în programele naþionale.
4 Opþionalul integrat introduce noi discipline structurate în jurul unei teme inte-
gratoare pentru o arie curricularã sau pentru mai multe arii curriculare
5 Opþionalul ca disciplinã care apare în trunchiul comun la alte specialãzãri dis-

pune de o programã deja elaboratã la nivel central, ca programã obligatorie în
cadrul unei anumite specialãzãri.
Structura programei de opþional este aproximativ aceeaºi cu cea a programelor de
trunchi comun elaborate la nivel naþional. În plus apare un Argument care motiveazã
cursul propus, nevoile elevilor, ale comunitãþii locale, formarea unor competenþe de
transfer.
A. Argument
B. Competenþe specifice C. Conþinuturi
1.
2.
3.
….
D. Valori ºi atitudini
E. Sugestii metodologice
Tabel sintetic care asociazã tipurilor de opþional caracteristici obligatorii ale pro-
gramei ºi modalitatea de notare în catalog
Tip de opþional Caracteristici ale programei Notare în catalog
Opþionalul de aprofundare
• Aceleaºi competenþe Aceeaºi rubricã în catalog cu
• Noi conþinuturi disciplina sursã
• Noi competenþe specifice corelate cu
Opþionalul de extindere cele din programa de trunchi comun Aceeaºi rubricã în catalog
• Noi conþinuturi corelate cu cele din
programa de trunchi comun
• Noi competenþe specifice diferite de
Opþionalul ca disciplinã nouã cele din programa de trunchi comun Rubricã nouã în catalog
• Noi conþinuturi diferite de cele din pro-
grama de trunchi comun
Opþionalul integrat
• Noi competenþe specifice complexe Rubricã nouã în catalog
• Noi conþinuturi interdisciplinare
Modulele din programa de clasa a XII-a, specializarea matematicã – informaticã

pot constitui bazã pentru proiectarea unui opþional ca disciplinã nouã, opþional inte-
grat sau Opþional ca disciplinã care apare în trunchiul comun la alte specializãri, pen-
tru alte specializãri din filiera teoreticã sau vocaþionalã.
VI.1. Anexa 1
a) Planificare calendaristicã
Liceul........................... Profesor: ...........................................
Disciplina INFORMATICÃ Clasa a XII-a , 3 ore/sãpt
Planificare calendaristicã
Anul ºcolar 2007-2008
Nr. Unitãþi de Competenþe Nr.

Conþinuturi Sãptãmâna Observaþii
Crt. învãþare specifice Ore
• Limbajul C# (structura unui proiect, decla-

rãri de date, citiri/scrieri folosind dispozitive
strandard, instrucþiuni, structuri de control,
structuri de date)
1 Limbajul C#
1.3, 1.4, 3.1, • Interfaþa Visual Studio .Net, C# (meniuri,
12 S1-S3
3.2 bare de instrumente, etapele realizãrii unei
aplicaþii consolã, tehnici de depanare ºi
autodocumentare)
• Programare proceduralã (subprograme,
tehnici de transfer al parametrilor)
• Principiile programãrii orientate pe obiecte

• Clase (structura clasei: date, metode ºi pro-
prietãþi, constructori, destructor)
Programare
• Obiecte (instanþiere, specificatori de acces,
1.1, 1.2, 1.3, membri statici ai unei clase)
2 Orientatã pe 21 S4-S10
Obiecte
1.4, 3.1 • Derivare (moºtenire, definire ºi redefinire de
metode, clase ºi metode abstracte, clase ºi
metode sigilate, polimorfism)
• Ierarhii de clase predefinite (using)
• Aplicaþii consolã cu clase
• Elemente de bazã ale programãrii vizuale

(clase predefinite, interfaþã, evenimente,
excepþii)
• Ferestre (crearea ºi particularizarea formu-
larelor)
• Controale Standard, Container ºi Compo-
Programare 1.1, 2.1, 2,2, nents (proprietãþi, evenimente specifice,
3 21 S11-S17
vizualã 3.1,3.2 metode asociate evenimentelor, Sender)
• Obiecte de tip dialog ºi obiecte grafice
• Tratarea excepþiilor (ierarhia claselor de
erori, try-catch-finally-throw)
• Construirea unei aplicaþii vizuale (proiect,
spaþiu de nume, bare de instrumente, mo-
duri de vizualizare ºi instrumente de depanare)
• Structuri de date înlãnþuite (liste, stive, cozi,

clase generice; foreach)
Structuri de • Baze de date (conexiuni, tabele, relaþii, con-
date 1.1, 1.2, 1.3, troale de tip DataSet, DataGridView,
4 18 S18-S23
în mediu 1.4, 3.1, 3.2 TableAdapter)
vizual • Operaþii cu baze de date (comenzi SQL,
generarea ºi executarea comenzilor)
• Construirea unei aplicaþii cu liste ºi tabele
• Ciclul de viaþã al unui produs software

Dezvoltarea (alegerea temei, definirea cerinþelor utiliza-
ºi tor, modelarea soluþiei, implementarea ºi
2.1, 2.2, 2.3,
5 prezentarea testarea produsului) 30 S24-S33
3.1, 3.2, 3.3
unei aplicaþii • Modele arhitecturale
vizuale • Realizarea ºi documentarea proiectului
• Prezentarea proiectului
134 s1
b) Proiectarea unitãþii de învãþare
Liceul ................................. Sãptãmânile S1-S3,

INFORMATICÃ Clasa a XII-a , 3 ore/sãptãmânã
Proiectul unitãþii de învãþare

An ºcolar 2007-2008
Unitatea 1. Limbajul C# (12 ore)
Nr.
Conþinuturi C.S. Activitãþi de învãþare Resurse Evaluare Observaþii
Crt.
• Familiarizare/repetare
Limbajul C# sintaxã C
- structura unui proiect • Program C# pentru o prelu- Conversaþia, se preferã
- declarãri de dat 2.1
crare simplã (simplificare modelarea, algoritmi
1
- citiri/scrieri folosind dis- 2.2
fracþie, termeni Fibonacci din exerciþiul Observare din
pozitive strandard interval, cifra de control etc.) Act.frontalã sistematicã tematica de
1.4
- instrucþiuni ºi structuri • Realizare aplicaþie consolã atestat ºi
de control corespunzãtoare 3 ore bacalaureat
- structuri de date • Tipuri de date noi în C#.
ªiruri de caractere
• Discutarea structurii unui

proiect simplu ºi enume-
rarea etapelor de realizare
a acestuia Exerciþiul,
Interfaþa Visual Studio .Net • Exersarea principalelor demon-
(C#) opþiuni din meniuri, butoane strarea Act.
- meniuri ºi bare de ºi shorcut-uri pentru frontalã ºi
Observare
instrumente realizarea unei aplicaþii individualã
2 3.1 sistematicã
- etapele realizãrii unei consolã Fiºa de
Investigaþie
aplicaþii consolã • Program de prelucrare activ.
- tehnici de depanare ºi stringuri (inversare nume- Practicã
autodocumentare prenume, criptãri sau codi-
ficãri etc.) 3 ore
• Aplicaþie consolã cu tablouri
(ordonare, diagonale matrice
etc.)
• Definire funcþie (prim, palin- Exerciþiul

drom etc.) ºi subprogram Act.frontalã
Programare proceduralã procedural (transformare, ºi
Fiºa de
3
- subprograme 2.1
citire, afiºare matrice, individualã
evaluare
- tehnici de transfer al ordonare vector etc.) Test
1.1
parametrilor • Aplicaþie consolã care ape- evaluare
leazã funcþia ºi procedura
definite 3 ore
• Realizarea unei aplicaþii-joc Conversaþia,

simple (centrate ºi necen-
exerciþiul
Realizarea unor aplicaþii trate, X ºi O, corãbii etc.)
Act.frontalã Fiºa de
4
consolã cu algoritmi 3.1 • Discutarea algoritmilor de
ºi evaluare
elementari, structuri de 3.2 prelucrare, implementarea ºi
individualã 1.2
date ºi subprograme testarea subprogramelor,
implementarea aplicaþiei
3 ore
consolã
c) Instrumente de evaluare
FIªA DE EVALUARE 1.1
Nr.1
1. (1p.) Care dintre urmãtoarele variante reprezintã antetul corect al unui subprogram cif1
care primeºte o valoare realã prin intermediul parametrului r ºi returneazã prin inter-
mediul parametrului z numãrul de cifre aflate la partea întreagã a lui r (de exemplu
pentru r=5.12703, z va returna valoarea 1, iar pentru r=126, z va returna valoarea 3)
a) static void cif1(ref float r,int z)
b) static void cif1(float r, ref int z)
c) int void cif1(float r)
d) static float cif1(int z)
2. (1p.) Se ºtie cã sunt declarate o variabilã x ºi ea reþine o valoare realã oarecare ºi o variabi-
la întreagã k ºi ea reþine valoarea 0. Care dintre urmãtoarele variante reprezintã un
apel corect al subprogramului cif1 de la cerinþa 1?
a) cif1(x,k)
b) k=cif1(x,0)
c) cif1(x,ref k)
d) cif1(ref x, k)
3. (4p.) Scrieþi secvenþa de program ce realizeazã prelucrarea cerutã la 1. Valoarea variabilei

reale x este consideratã cunoscutã, iar valoarea calculatã a lui z nu se va afiºa.
4. (3p.) Considerând implementat subprogramul cif1, scrieþi un program care citeºte de la

tastaturã o valoare realã ºi, folosind apeluri ale subprogramului cif1, verificã dacã
aceastã valoare are mai multe cifre la partea întreagã decât la cea zecimalã. Se va
afiºa unul dintre mesajele DA sau NU.
136 ANEXA 1
FIªA DE EVALUARE 1.1
Nr.2
1. (1p.) Care dintre urmãtoarele variante reprezintã antetul corect al unui subprogram cif2
care are un singur parametru r prin intermediul cãruia primeºte o valoare realã cif2
va returna numãrul de cifre aflate la partea zecimalã semnificativã a lui r (de exemplu
pentru r=5.120700, subprogramul va returna valoarea 4, iar pentru r=126, va returna val-
oarea 0)
a) static void cif2(ref float r,int z)
b) static void cif2(float r, ref int z)
c) static int cif2(float r)
d) static float cif2(ref float r)
2. (1p.) Se ºtie cã sunt declarate o variabilã x ºi ea reþine o valoare realã oarecare ºi o vari-
abilã întreagã k ºi ea reþine valoarea 0. Care dintre urmãtoarele variante reprezintã un
apel corect al subprogramului cif2 de la cerinþa 1?
a) cif2(x,k)
b) k=cif2(x)
c) cif2(x,ref k)
d) k=cif2(x,ref k)
3. (3p.) Scrieþi secvenþa de program ce realizeazã prelucrarea cerutã la 1. Valoarea variabilei

reale x este consideratã cunoscutã, iar valoarea determinatã se va afiºa.
4. (3p.) Considerând implementat subprogramul cif2, scrieþi un program care citeºte de la

tastaturã o valoare realã ºi, folosind apeluri ale subprogramului cif2, verificã dacã
aceastã valoare are mai multe cifre la partea întreagã decât la cea zecimalã. Se va
afiºa unul dintre mesajele DA sau NU.
VI.2. Anexa 2
a) Planificare calendaristica
Unitatea ºcolarã……………………………. Profesor………………………..
Disciplina INFORMATICÃ Clasa/Nr.Ore/sãpt 3 ore/sãpt
Planificarea calendaristicã
MODUL Programare orientatã pe obiecte ºi programare vizualã

(1 orã teorie + 2 ore activitaþi practice sau 3 ore activitãþi practice)
Nr. Unitãþi de Nr.

Competenþe specifice Conþinuturi Sãptãmânã Observatii
crt. învãþare ore
C1 Insuºirea conceptelor
de abstractizare a 1.1 Principiile programãrii
3 S1
datelor orientate pe obiecte
C2 Folosirea terminolo-
giei specifice POO în 1.2 Structura unei aplicaþii
12 S2-S5
contexte variate de orientatã pe obiecte
aplicare
C3 Organizarea datelor
1.3 Clase ºi obiecte 33 S6-S16
ce intervin în
PROGRAMAREA
rezolvarea unei pro-
1. ORIENTATÃ PE
bleme utilizând 1.4 Derivarea claselor 6 S17-S18
OBIECTE
structuri de date
adecvate
C4 Utilizarea facilitãþilor 1.5 Tratarea erorilor 3 S19
oferite de POO
C5 Elaborarea ºi 1.6 Polimorfism 3 S20
realizarea unei apli-
caþii, folosind un
mediu de progra- 1.7 Recapitulare 3 S21
mare specific
C6 Exprimarea ºi
redactarea coerentã
2.1 Concepte de bazã ale
în limbaj formal sau 3 S22
programãrii vizuale
în limbaj cotidian, a
rezolvãrii sau a
strategiilor de
rezolvare a unei 2.2 Prezentarea unui
probleme mediu de programare
vizual (Microsoft Visual 3 S23
C7 Analiza de situaþii-
problemã în scopul C#, Delphi, Microsoft
descoperirii de Visual Basic etc.).
strategii pentru opti-
mizarea soluþiilor
C8 Generalizarea unor 2.3 Elementele POO în
3 S24
proprietãþi prin mo- context vizual
PROGRAMAREA dificarea contextului
2.
VIZUALÃ iniþial de definire a
problemei sau prin
generalizarea algorit-
2.4 Construirea interfeþei
milor 15 S25-S29
utilizator
C9 Întelegerea principiilor
de proiectare a inter-
fetelor C10) Utilizarea
instrumentelor de
dezvoltare a unei apli- 2.5 Accesarea ºi prelu-
12 S30-S33
caþii C11) Elaborarea crarea datelor
ºi realizarea unei apli-
caþii, folosind un
mediu de programare
specific C12) 2.6 Dezvoltarea ºi
prezentarea unei apli- 6 S34-S35
Prezentarea unei apli-
caþii caþii în mediu vizual
138 ANEXA 2
b) Proiectul unitãþii de învãþare
Unitatea ºcolarã………………………. Sãptãmâna/ Anul………….…………..

Disciplina INFORMATICÃ Clasa/Nr. Ore /sãpt……… 3ore/sãpt.
Profesor………………………….....…..
Proiectul unitatii de invatare
Unitatea de învãþare PROGRAMAREA ORIENTATÃ PE OBIECTE

Nr. Ore alocate: 63
Evaluare
Resurse Tip/ Observaþii
Nr.
Conþinuturi C.S. Activitãþi de învãþare instrument
Crt
Temporale Forme de
Materiale
(ore) organizare
- pentru a ilustra principi-

ile programãrii orientatã
pe obiecte ºi modul de
structurare a unei apli- Iniþialã/
Principiile caþii POO se va prezenta Studiu de
programãrii ºi analiza o aplicaþie caz
1. C1 3 Frontalã Anexa 1
orientate pe gata implementatã; se Jurnal
va realiza o analizã Reflexiv
obiecte comparativã între abor- Anexa 2
darea POO în raport cu
abordarea specificã pro-
gramãrii structurate;
Structura unei aplicaþii orientatã pe obiecte
2.1 Arhitectura
platformei - analiza arhitecturii plat-
Microsoft formei .NET
.NET, compo- - formularea trãsãturilor
nente ale lui platformei .NET
.NET - identificarea caracteristi-
Framework, cilor fiecãrei componente Formativã/
trãsãturi ale C1 ale platformei .NET Individualã
R.A.I.
platformei C2 - exerciþii de descriere a 3 Frontalã Anexa 3
Anexa 4
.NET C4 metodei de rezolvare a Pe grupe
Anexa 5
2.2 Structura gen- unei probleme din per-
eralã a unei spectiva structurãrii
2. aplicaþii C# datelor;
2.3 Tipuri de date - exerciþii de utilizare a
(predefinite,val selecþiei, iteraþiei ºi saltului
oare, enumer- - exerciþii de identificare a
are) tipurilor de date necesare
în aplicaþii
- formularea unor probleme
simple; discuþii prelimi-
nare ºi analiza problemei;
2.4 Tablouri - formularea ºi rezolvarea
Tablouri unidi- C2 unor probleme care Individualã
Anexa 6 Formativã/
mensionale, C4 necesitã utilizarea datelor 6 Frontalã
Anexa 7 Exerciþiul
Tablouri multi- C5 structurate Pe grupe
dimensionale
C2 Individualã
Formativã/
2.5 String-uri C4 3 Frontalã Anexa 8
Exerciþiul
C5 Pe grupe
Evaluare Tip/
Resurse Observaþii
instrument
Nr.
Conþinuturi C.S. Activitãþi de învãþare Tempo-
Crt Forme de
rale Materiale
organizare
(ore)
Clase ºi obiecte
3.1.Definirea C2 Iniþialã/
claselor ºi a 3 Frontalã Anexa 9
C4 - pentru ca elevii sã înþe- Exerciþiul
obiectelor
C2 leagã diferenþele speci- Anexa 10 Formativã/
3.2.Utilizarea Frontalã
C3 fice abordãrii POO, se 3 Anexa 11 Exerciþiul T
claselor ºi a
va alege una dintre apli- Individualã
obiectelor C4 Anexa 12 3-2-1
caþiile familiare elevilor
3.3.Specificatori de Frontalã
C2 (de exemplu: numere Formativã/
acces la membrii 6 Individualã Anexa 13
C5 complexe, numere Exerciþii
unei clase Pe grupe
raþionale, polinoame,
3.4.Funcþii. C2 liste, etc.), care va fi Frontalã Formativã/
Transmiterea 3 Anexa 14
C5 analizatã din perspecti- Individualã R.A.I.
3. parametrilor va POO, apoi se vor
3.5.Crearea C2 implementa clasele Frontalã Formativã
obiectelor; necesare ºi se va realiza 3 Anexa 15
C4 Individualã Exerciþiul
Constructori o aplicaþie în care vor fi
3.6.Distrugerea C2 utilizate clasele create; Frontalã
Formativã/
obiectelor C4 exerciþii de utilizare a 3 Individualã Anexa 16
Exerciþiul
Destructori C5 conversiilor -exerciþii Pe grupe
C2 care implicã boxing ºi Frontalã Formativã
3.7.Operatori unboxing -exerciþii de
3 Anexa 17
C3 Individualã Exerciþiul
C3 definire ºi apelare a Frontalã Formativã
3.8.Delegaþi metodelor -exerciþii de 3 Anexa 18
C4 Individualã Exerciþii
utilzare a delegãrilor
C2 Frontalã Formativã/
3.9.Evenimente 6 Anexa 19
C5 Individualã Studiu de caz
Derivarea claselor
Definirea noþiunii de
- se va analiza un exem-
moºtenire simplã ºi
plu de ierarhie de clase Formativã
moºtenire multiplã C2
gata implementatã, Frontalã T 3-2-1
Declararea unei clase C3
4 pentru a înþelege 6 Individualã Anexa 21 Studiu de
derivate C4
mecanismele care Pe grupe caz
Drepturi de acces în C5
guverneazã derivarea Exerciþiul
clase derivate
claselor;
Constructori ºi des-
tructor în clase derivate
Tratarea erorilor - discuþii privind validi-
Ce este o eroare C2 tatea datelor;
Formativã/
Cum se genereazã C3 - testarea ºi analizarea Frontalã
5 3 Anexa 22 Exerciþii
Tratarea/propagarea C4 comportamentului apli- Individualã
R.A.I.
erorilor C5 caþiilor pentru diferite
Ierarhia claselor de erori date de intrare;
Polimorfism C2
Funcþii virtuale Clase C3 Frontalã Formativã/
6 3 Anexa 23
abstracte ºi funcþii C4 Individualã T 3-2-1
virtuale pure C5
- fiecare elev va alege o
problemã concretã, va
defini clasele/ierarhiile
de clase necesare ºi va
crea o aplicaþie în care
sã fie utilizate
C1
clasele/ierarhiile de
C2 Frontalã
clase create; în acest Sumativã/
7 Recapitulare C3
scop se poate folosi un
3 Individualã
Proiect
C4 Pe grupe
mediu vizual; elevii vor
C5
prezenta colegilor apli-
caþiile create; profesorul
va stimula discuþiile cri-
tice ºi creative pe mar-
ginea aplicaþiilor elabo-
rate de elevi;
140 ANEXA 3
VI.3. Anexa 3
a) Planificare calendaristicã
PROGRAMARE WEB
Unitatea ºcolarã……………………………. Profesor………………………..

Disciplina INFORMATICÃ Clasa/Nr.Ore/sãpt 3 ore/sãpt
Planificarea calendaristicã
Nr. Nr.
Unitãþi de învãþare Competenþe specifice Conþinuturi Sãpt.
Crt. Ore
Principii generale 1.1 Analizarea unei probleme în
1. Etapele procesului de dezvoltare
ale proiectãrii inter- scopul identificãrii ºi clasi- 2h 1
a unei aplicaþii Web
feþelor Web ficãrii resurselor necesare
1.1 Analizarea unei probleme în
2. Aspecte generale ale proiectãrii
scopul identificãrii ºi clasi- 2h 1-2
interfeþelor Web
ficãrii resurselor necesare
2.1 Identificare tehnicilor de
programare adecvate 3. Realizare interfeþelor Web
7h 2-4
rezolvãrii unei probleme ºi utilizând HTML
1.
aplicarea creativã a acestora
3.28 Utilizarea foilor de stil, a
principiilor de bazã ale
structurii unei foi de stil
3.29 Folosirea comenzilor 4. Foi de stiluri (CSS) 6h 4-6
asociate foilor de stil CSS,
ale stilurilor CSS în
paginile HTML
5. Evaluare sumativã 1h 6
3.1 Utilizarea instrumentelor de 1. Modelul client - server,
1h 7
dezvoltare a unei aplicaþii protocoale de comunicaþii
3.1 Utilizarea instrumentelor de
2. Server Web - IIS 1h 7
2. Mediul de lucru dezvoltare a unei aplicaþii
3.1 Utilizarea instrumentelor de 4. Prezentarea limbajului de 13h 7-11
dezvoltare a unei aplicaþii scripting - ASP 15h 12-16
5. Evaluare sumativã 3h 17
1. Definirea ºi gestionarea unei
3.24 Operarea cu baze de date 3h 18
baze de date
3.25 Utilizarea informaþiilor
dintr-o bazã de date
2. Lucrul cu baze de date 18h 19-24
3.26 Aplicarea operaþiilor ele-
mentare pe o bazã de date
3.1 Utilizarea instrumentelor de
Interaþiunea cu baze
3. dezvoltare a unei aplicaþii
de date Web
3.22 Elaborarea ºi realizarea unei
aplicaþii folosind un mediu
de programare specific 3. Proiectarea ºi realizarea unei
33 h 25-35
2.3 Analiza comparativã a efi- aplicaþii Web
cienþei diferitelor tehnici de
rezolvare a problemei
respective ºi alegerea celei
mai eficiente variante
TOTAL 105h
BIBLIOGRAFIE
• Marshall Donis, Programming Microsoft Visual C# 2005: The Language, Microsoft Press 2006,
ISBN:0735621810
• Pelland Patrice, Build a Program NOW, Microsoft Visual C# 2005 Express Edition, Microsoft Press
2006,
• LearnVisualStudio.NET http://www.learnvisualstudio.net resurse educaþionale gratuite sub forma de
filme
• Harris Andy, Microsoft C# Programming for the Absolute Beginner, Premier Press 2002,
ISBN: 1?931841?16?0
• Wright Peter, Beginning Visual C# 2005 Express Edition: From Novice to Professional, Apress 2006,
ISBN-13 (pbk): 978-1-59059-549-7, ISBN-10 (pbk): 1-59059-549-1
• Liberty Jesse, Programming C#, Second Edition, O'REILLY 2002, ISBN 10: 0-596-00309-9,
ISBN 13:9780596003098
• Solis Daniel, Illustrated C# 2005, Apress 2006, ISBN-13 (pbk): 978-1-59059-723-1,
ISBN-10 (pbk): 1-59059-723-0
• Rasheed Faraz, C# School, Synchron Data 2005-2006,
http://www.programmersheaven.com/2/CSharpBook
• Schneider Robert, Microsoft® SQL Server™ 2005 Express Edition For Dummies®, Wiley Publishing
2006, ISBN-13: 978-0-7645-9927-9, ISBN-10: 0-7645-9927-5
• Bradley L. Jones, Sams Teach Yourself the C# Language in 21 Days, SAMS, 2004,
International Standard Book Number: 0-672-32546-2
• Michel de Camplain, Brian G. Patrik, C# 2.0: Practical Guide for Programmers, Elsevier, 2005,
ISBN: 0-12-167451-7
• Christian Nagel, Bill Evjen, Jay Glynn, Karli Watson, Morgan Skinner, Allen Jones,
Professional C# 2005, Wiley Publishing, Inc., 2006, ISBN-13: 978-0-7645-7534-1
ISBN-10: 0-7645-7534-1
• Sharp John, Visual C# 2005, DUNOD 2006
• Iulian Serban, Dragos Brezoi, Tiberiu Radu, Adam Ward, GDI+ Custom Controls with Visual C#
2005, PACKT Publishing 2006, ISBN 1-904811-60-4
• Simpson Alan, Visual Web Developer Server™ 2005 Express Edition For Dummies®, Wiley
Publishing 2006, ISBN-13: 978-0-7645-8360-5, ISBN-10: 0-7645-8360-3
• Hoffman Kevin, Microsoft® Visual C# 2005 Unleashed, Sams 2006,
ISBN-10: 0-672-32776-7, ISBN-13: 978-0-672-32776-6
• Popovici, Dorin Mircea ºi colaboratorii - Proiectare ºi implementare software,
Editura TEORA, Bucureºti, 1998
• C# Language Specification, Microsoft Corporation, 1999-2003
• C# Version 2.0 Specification May 2004, Microsoft Corporation, 1999-2005
• David Conger, Programarea în C#, editura B.I.C. ALL 2003
• Chris H. Pappas, William H. Murray C# pentru programarea Web, editura B.I.C. ALL 2004
• MCAD/MCSD -Developing XML WEB SERVICES and SERVER COMPONENTS WITH MICROSOFT
http://www.csharp-station.com
http://msdn2.microsoft.com
• M.E.C. Serviciul Naþional de Evaluare ºi Examinare - Ghid de evaluare,
INFORMATICA ºi TEHNOLOGIA INFORMATIEI, Editura Aramis, Bucureºti 2001
• M.E.C. Consiliul Naþional pentru Curriculum - Ghid metodologic pentru aplicarea programelor
ºcolare, Editura Aramis, Bucureºti 2002
• M.E.C Consiliul Naþional pentru curriculum - Ghid metodologic pentru Educaþie Tehnologicã
Informaticã - Tehnologia Informaþiei - Liceu teoretic - Editura Aramis, Bucureºti 2001
Autori, în ordine alfabetică:
Adrian Niţă
Suport de curs pentru profesori
Introducere în
.Net Framework
ISBN: 973-86699-6-0
Ediţia 2008

Introducere in .Net Framework - Suport de Curs Pentru Profesori

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introducere in .Net Framework - Suport de Curs Pentru Profesori

Uploaded by

Copyright:

Available Formats

Autori, în ordine alfabetică:

Sistem de operare suportat:

Introducere în .NET Framework este un curs dezvoltat în cadrul programului

Cursul vã propune sã exploraþi tehnologia .NET, cea mai rãspânditã platformã de

Suportul de curs poate fi descãrcat gratuit ºi folosit exclusiv în procesul educaþional.

Scopul acestei iniþiative a programului Parteneri pentru Educaþie este de a încuraja

Împreunã cu partenerii, echipa Microsoft România vã mulþumeºte pentru interesul

Sperãm doamnelor ºi domnilor profesori, ca aceste materiale sã vã ajute în predarea

Adrian Niþã, profesor, Colegiul Naþional „Emanuil Gojdu”, Oradea

Mihai Tãtãran, cadru didactic asociat, Universitatea Politehnica din Timiºoara

Formatul electronic al textului digital: PDF

2. Platforma .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .21

3.11.2. Instrucþiunea while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40

4. Programarea web cu ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47

5. Programare vizualã . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .59

7. MiniGhid Metodologic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .109

1.1 Evolutia tehnicilor de programare

Se observã cã modulele sunt ”centrate” pe proceduri, acestea gestionând ºi setul

capabile de acþiuni specifice ºi care interacþioneazã în cadrul programului); intervin

1. 2 Tipuri de date obiectuale. Încapsulare

aferent datelor sale, se aplicã o metodã specificã numitã destructor1.

1.5. Polimorfism. Metode virtuale

1.6. Programare orientatã obiect în C#

1.7. Declararea unei clase

utilizator, metode (subprograme), constructori, un destructor, proprietãþi (caracteris-

Modificatorul abstract este folosit pentru a desemna faptul cã nu se pot obþine

J Utilizarea unui constructor fãrã parametri ºi a constructorului implicit în clasã

public abstract class Copil

J Supraîncãrcarea constructorilor ºi definirea explicitã a constructorilor în clase

public class Copil

13 Preia ºi specializeazã constructorul al doilea din clasa de bazã

public class Copil

referinþa noului obiect se memoreazã în tabloul static copii (caracteristic clasei) ºi

Baiat c = new Baiat(); Copil.adaug_copil(c);

Definirea datelor ºi metodelor nestatice corespunzãtoare clasei Copil ºi claselor

public class Copil

Fetita c = new Fetita();c.se_joaca(“pisica”);c.se_joaca(); //polimorfism

Pentru a evidenþia mai bine comportamentul polimorfic, propunem secvenþa

for (int i=0; i<nr_copii; i++) copii[i].se_joaca();

public class Copil

public Copil() {Nume = Console.ReadLine();} //metoda set

1.12. Evenimente ºi delegãri

public delegate bool pereche_ok(object t1, object t2);

{ for (int i = 0; i < nmax; i++) Console.Write(“{0}, “, v[i]);

Dacã în clasa-program21 se adugã funcþiile (exprimând douã “reguli de aranjare”

public static bool f1(object t1, object t2)

atunci o secvenþã de prelucrare aplicativã ar putea fi:

static void Main(string[] args)

Revenind la evenimente, descriem pe scurt un exemplu teoretic de declarare ºi

21 Independent de definiþia clasei Vector

depunere la bancã, putem determina venitul total:

Actiune act1 = new Actiune();Actiune act2 = new Actiune();

între aplicaþiile .NET ºi sistemul de operare ºi actualmente conþine:

Arhitectura .NET Framework

2.2. Compilarea programelor

În plus, CLR se ocupã de gestionarea automatã a memoriei (un mecanism imple-

2.3. De ce am alege .NET?

3.2. Compilarea la linia de comandã

Dacã se salveazã fiºierul primul.cs, în directorul WINDOWS\Microsoft.NET\

3.3. Crearea aplicaþiilor consolã

Fereastra în care scriem programul se numeºte implicit Programs.cs ºi se poate

Compilarea programului se realizeazã cu ajutorul opþiunii Build Solution (F6) din

Fereastra de cod ºi ferestrele auxiliare ce ne ajutã în etapa de editare pot fi vizua-

3.4. Structura unui program C#

<input type=”hidden” name=”VIEWSTATE” id=”VIEWSTATE”