Introducere in .Net Framework Suport de Curs Pentru Elevi

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 elevi
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
Dragi elevi,
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 com-
ponenta de specialitate. Versiunea pentru profesori cuprinde pe lângã componenta
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 dragi elevi, sã vã dezvoltaþi potenþialul tehnic ºi creativ pentru a deveni

competitivi dupã absolvirea liceului.
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-5-2
Notã:
Acest suport de curs este destinat elevilor de 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
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 .
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 elevi
Introducere în
.Net Framework
ISBN: 973-86699-5-2
Ediţia 2008

Introducere in .Net Framework Suport de Curs Pentru Elevi

Încărcat de

Drepturi de autor:

Formate disponibile

Introducere in .Net Framework Suport de Curs Pentru Elevi

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Introducere in .Net Framework Suport de Curs Pentru Elevi

Încărcat de

Drepturi de autor:

Formate disponibile

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 dragi elevi, sã vã dezvoltaþi potenþialul tehnic ºi creativ pentru a deveni

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

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