P. 1
Introducere în .Net Framework

Introducere în .Net Framework

4.0

|Views: 1,491|Likes:
Published by Cătălin

More info:

Published by: Cătălin on Apr 26, 2009
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

05/11/2014

pdf

text

original

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 Politehnică Timișoara Nușa Dumitriu-Lupan inspector General MECT Petru Jucovschi Developer Community Lead, Microsoft România

Suport de curs pentru profesori

.Net Framework
Ediţia 2008

Introducere în

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, educaþionale. colecþie de instrumente software ºi resurse

Cuvânt Înainte

Stimaþi profesori, Introducere în .NET Framework este un curs dezvoltat în cadrul programului Microsoft Parteneri pentru Educaþie, în colaborare cu un grup de profesori de informaticã din România. Pânã la sfârºitul anului ºcolar 2007-2008 va fi disponibil în pe situl Microsoft România, în pagina Secþiuni pentru educaþie. Cursul vã propune sã exploraþi tehnologia .NET, cea mai rãspânditã platformã de aplicaþii software. Aveþi posibilitatea sã studiaþi soluþii software ºi sã dezvoltaþi aplicaþii ce pot fi trimise la concursuri sau pot fi integrate în proiecte educaþionale. Suportul de curs este publicat în douã versiuni. Cea pentru elevi cuprinde doar componenta de specialitate. Versiunea pentru profesori cuprinde pe lângã 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 doamnelor ºi domnilor profesori, ca aceste materiale sã vã ajute în predarea materiei la clasã!

Sanda Foamete SNR Manager de Proiecte Educaþionale Microsoft România

Autori, în ordine alfabeticã:

Adrian Niþã, profesor, Colegiul Naþional „Emanuil Gojdu”, Oradea Maria Niþã, profesor, Colegiul Naþional „Emanuil Gojdu”, Oradea Nicolae Olãroiu, profesor Colegiul Naþional „B.P. Haºdeu”, Buzãu Rodica Pintea, profesor, Liceul „Grigore Moisil”, Bucureºti (capitolul 1) Cristina Sichim, profesor, Colegiul Naþional „Ferdinand I”, Bacãu Daniela Tarasã, Inspector Informaticã, ISJ Bacãu

Coordonatori:

Mihai Tãtãran, cadru didactic asociat, Universitatea Politehnica din Timiºoara Nuºa Dumitriu-Lupan, Inspector General MECT Petru Jucovschi, Developer Community Lead, Microsoft România

Formatul electronic al textului digital: PDF Editat de BYBLOS SRL sub coordonarea Agora Media SA, pentru Microsoft România. Ediþia 2008. ISBN: 973-86699-6-0

Notã: Acest suport de curs este destinat profesorilor ce predau la clasele matematicã-informaticã ºi matematicã-informaticã intensiv, care au optat în programa ºcolarã, pentru variantele: Programare orientatã obiect, Progamare vizualã cu C# ºi Programare web cu Asp.Net. Suportul de curs poate fi utilizat gratuit exclusiv în procesul de predare-învãþare. Este interzisã utilizarea suportului de curs „Introducere în .Net Framework” pentru scopuri comerciale sau în alte scopuri în afara celui descris mai sus. Drepturile de autor asupra suportului de curs „Introducere în .Net Framework” aparþin Microsoft.

Introducere în .Net Framework (Suport de curs)

3

CUPRINS
1 Programarea Orientatã Obiect (POO) cu C# . . . . . . . . . . . . . . . . . . . . . . . . . . . .7
1.1. Evoluþia tehnicilor de programare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7 1.2. Tipuri de date obiectuale. Încapsulare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8 1.3. Supraîncãrcare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9 1.4. Moºtenire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10 1.5. Polimorfism. Metode virtuale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10 1.6. Programare orientatã obiect în C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11 1.7. Declararea unei clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11 1.8. Constructori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12 1.9. Destructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 1.10. Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 1.11. Proprietãþi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16 1.12. Evenimente ºi delegãri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .17 1.13. Interfeþe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .19

2.

Platforma .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .21
2.1. Prezentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .21 2.2. Compilarea programelor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22 2.3. De ce am alege .NET? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23

3.

Limbajul C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25
3.1. Caracterizare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25 3.2. Compilarea la linia de comandã . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25 3.3. Crearea aplicaþiilor consolã . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26 3.4. Structura unui program C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27 3.5. Sintaxa limbajului . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .28 3.6. Tipuri de date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30 3.7. Conversii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .34 3.7.1. Conversii numerice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .34 3.7.2. Conversii între numere ºi ºiruri de caractere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .36 3.7.3. Conversii boxing ºi unboxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .38 3.8. Constante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .39 3.9. Variabile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .39 3.10. Expresii ºi operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .39 3.11. Instrucþiuni condiþionale, de iteraþie ºi de control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40 3.11.1. Instrucþiunea if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40

4

Introducere în .Net Framework (Suport de curs)

3.11.2. Instrucþiunea while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40 3.11.3. Instrucþiunea do – while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .41 3.11.4. Instrucþiunea for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .42 3.11.5. Instrucþiunea switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .42 3.11.6. Instrucþiunea foreach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43 3.11.7. Instrucþiunea break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43 3.11.8. Instrucþiunea continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .43 3.11.9. Instrucþiunea goto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .44 3.12. Instrucþiunile try-catch-finally ºi throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .45

4.

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

5.

Programare vizualã . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .59
5.1. Concepte de bazã ale programãrii vizuale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .59 5.2. Mediul de dezvoltare Visual C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61 5.3. Ferestre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62 5.4. Controale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64 5.4.1. Controale form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65 5.4.2. Proprietãþi comune ale controalelor ºi formularelor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65 5.4.3. Câteva dintre metodele ºi evenimentele Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .66 5.5. System.Drawing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .86 5.6. Validarea informaþiilor de la utilizator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .87

Introducere în .Net Framework (Suport de curs)

5

6.

ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89
6.1. Arhitectura ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90 6.2. Furnizori de date (Data Providers) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90 6.3. Connection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90 6.3.1. Exemple de conectare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91 6.3.2. Proprietãþi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91 6.3.3. Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92 6.3.4. Evenimente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92 6.4. Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92 6.4.1. Proprietãþi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93 6.4.2. Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .93 6.4.3. Interogarea datelor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95 6.4.4. Inserarea datelor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95 6.4.5. Actualizarea datelor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95 6.4.6. ªtergerea datelor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .96 6.5. DataReader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .99 6.5.1. Proprietãþi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .99 6.5.2. Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .99 6.6. DataAdapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .101 6.6.1. Proprietãþi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102 6.6.2. Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102 6.7. DataSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102 6.8. SqlParameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .104 6.9. Proceduri Stocate (Stored Procedures) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105 6.10. Proiectarea vizualã a seturilor de date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .106

7.

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

7

CAPITOLUL

1

Programarea Orientatã Obiect (POO) cu C#
1.1 Evolutia tehnicilor de programare
• Programarea nestructuratã (un program simplu, ce utilizeazã numai variabile globale); complicaþiile apar când prelucrarea devine mai amplã, iar datele se multiplicã ºi se diversificã. • Programarea proceduralã (program principal deservit de subprograme cu parametri formali, variabile locale ºi apeluri cu parametri efectivi); se obþin avantaje privind depanarea ºi reutilizarea codului ºi se aplicã noi tehnici privind 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 procedurile 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 avantaje 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

8

Introducere în .Net Framework (Suport de curs)

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 relevante, î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, formatã din valori efective ale datelor. Un tip de date obiectual este un tip de date care implementeazã un tip de date abstract. Vom numi operaþiile implementate în cadrul tipului de date 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 (subprograme) capabile sã creeze o stivã vidã, care sã introducã o valoare în stivã, sã extragã valoarea din vârful stivei, sã testeze dacã stiva este vidã sau dacã stiva 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 valori dintr-o stivã în alta dupã o anumitã regulã desfiinþând orice stivã golitã, pânã ce rãmâne o singurã stivã. De observat cã toate aceste prelucrãri recurg la datele, constructorul, 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 obiectuale (struct, object). O instanþã a unui tip obiectual poartã numele de obiect. La implementare, datele ºi metodele asociate trebuie sã fie complet ºi corect definite, astfel încât utilizatorul sã nu fie nevoit sã þinã cont de detalii ale acestei implementã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 clasei, 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 anumit 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 reprezintã 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#.

10

Introducere în .Net Framework (Suport de curs)

î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 dife3 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.

CAPITOLUL 1. Programarea orientatã obiect (POO) cu C#

11

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 mecanismele 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 programare periculoase, limbajul oferã tipuri speciale cum ar fi: interfeþe ºi delegãri. Versiunii 2.0 a limbajului i s-a adãugat un nou tip: clasele generice8,

1.7. Declararea unei clase
Sintaxa9: [atrib]o [modificatori]o class [nume_clasã] [:clasa_de_bazã]o [corp_clasã]o Atributele reprezintã informaþii declarative cu privire la 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 singurã 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 stabileste 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ã

12

Introducere în .Net Framework (Suport de curs)

utilizator, metode (subprograme), constructori, un destructor, proprietãþi (caracteristici ce pot fi consultate sau setate), evenimente (instrumente de semnalizare), indexatori (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 ”context” 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ã contextele tuturor instanþelor clasei respective Exemplul urmãtor defineºte o ierarhie de clase (conform figurii alãturate)
public abstract class Copil { } public class Fetita: Copil { } public sealed class Baiat: Copil { }

Modificatorul abstract este folosit pentru a desemna faptul cã nu se pot obþine obiecte din clasa Copil, ci numai din derivatele acesteia (Fetita, Baiat), iar modificatorul sealed a fost folosit pentru a desemna faptul cã nu se mai pot obtine clase derivate din clasa Baiat (de exemplu, subclasele Baiat_cuminte ºi Baiat_rau)

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 constructorului 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)

CAPITOLUL 1. Programarea orientatã obiect (POO) cu C#

13

nou obiect al clasei respective (sau la crearea clasei, în cazul constructorilor cu modificatorul static). • pot exista mai mulþi constructori care se pot diferenþia prin lista lor de parametri • constructorii nu pot fi moºteniþi • dacã o clasã nu are definit niciun constructor, se va asigna 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) 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

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(){}

14

Introducere în .Net Framework (Suport de curs)

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 constructor. 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 identificator 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 acesteia, numãrul ºi tipul parametrilor16 Numele metodei trebuie sã difere de numele oricãrui alt membru care nu este metodã. La apelul metodei, orice parametru trebuie sã aibã acelaºi 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.

CAPITOLUL 1. Programarea orientatã obiect (POO) cu C#

15

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ã

16

Introducere în .Net Framework (Suport de curs)

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 proprietãþilor. Metodele de acces sunt douã: set ºi get. Dacã proprietatea nu este abstractã sau externã, poate sã aparã una singurã dintre cele douã metode de acces sau amândouã, în orice ordine. Este o manierã de lucru recomandabilã aceea de a proteja datele membru (câmpuri) ale clasei, definind instrumente de acces la acestea: pentru a obþ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 asimilabilã 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 problemei, se face o atribuire de felul câmp=value. Definirea în clasa Copil a proprietãþii Nume, corespunzãtoare câmpului protejat ce reþine, sub forma unui ºir de caractere, numele copilului respctiv. Se va observã cã proprietatea este moºtenitã ºi de clasele derivate Fetita ºi Bãiat19.
public class Copil {... string nume; // este implicit protected public string Nume //proprietatea Nume { get { if(char.IsUpper(nume[0]))return nume; else return nume.ToUpper();} set { nume = value; } }
19 Desigur cã proprietatea care controleazã accesul la câmpul identificat prin nume se poate numi cu totul altfel (proprietatea Nume fiind uºor de confundat cu câmpul de date nume).

CAPITOLUL 1. Programarea orientatã obiect (POO) cu C#

17

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_formali]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 accesul "general" la câmpul respectiv de date. Iar metodele ºi constructorii foloseau identificatorul nume ºi nu proprietatea Nume.

18

Introducere în .Net Framework (Suport de curs)

{

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 exemplu, va implementa o metodã M ce realizeazã animaþia ºi va adãuga pe M (prin intermediul unui delegat) la x.E24. Cumulând mai multe astfel de referinþe, x.E ajunge un fel de listã de metode (handlere). În clasa Vector, în metoda sort, la interschimbarea valorilor a douã componente se invocã delegatul E. Invocarea lui E 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 22 23 24

Independent de definiþia clasei Vector De exmplu indicii componentelor interschimbate A se observa cã evenimentul în sine este anonim, doar delegatul asociat are nume într-o atribuire de felul x.E+=new [tip_delegat](M)

CAPITOLUL 1. Programarea orientatã obiect (POO) cu C#

19

1.13. Interfeþe
Interfeþele sunt foarte importante în programarea orientatã pe obiecte, deoarece permit utilizarea polimorfismului într-un sens mai extins.O interfaþã este o componentã a aplicaþiei, asemãnãtoare unei clase, ce declarã prin membrii sãi (metode, proprietãþ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 aplicaþ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, evident, metodele respective, dar le pot ºi redefini (de exemplu, clasa Credit_acordat redefineºte metoda calc din clasa Investiþie, deoarece formula de calcul implementatã acolo nu i se ”potriveºte” ºi ei26). De exemplu, dacã presupunem cã toate clasele subliniate 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

20

Introducere în .Net Framework (Suport de curs)

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 versiunile 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 aplicaþiilor desktop Windows. Când dezvoltãm aplicaþii .NET, putem utiliza: • Servere specializate - un set de servere Enterprise .NET (din familia SQL Server 2000, Exchange 2000 etc), care pun la dispoziþie funcþii de stocare a bazelor de date, email, aplicaþii B2B (Bussiness to Bussiness – comerþ electronic între partenerii unei afaceri). • Servicii Web (în special comerciale), utile în aplicaþii care necesitã identificarea utilizatorilor (de exemplu, .NET Passport - un mod de 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þã

22

Introducere în .Net Framework (Suport de curs)

î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 aceste limbaje respectã niºte specificaþii OOP numite Common Type System (CTS). Ele au ca elemente de bazã: clase, interfeþe, delegãri, tipuri valoare ºi referinþã, iar ca mecanisme: moºtenire, polimorfism ºi tratarea excepþiilor. Platforma comunã de executare a programelor numitã Common Language Runtime (CLR), utilizatã de toate cele 4 limbaje. 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 executabile 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 versiunii 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ã formatul 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 implementat în platforma .NET fiind acela de eliberare automatã a zonelor de memorie asociate unor date devenite inutile – Garbage Collection). Ca un element de portabilitate, trebuie spus cã .NET Framework este implementarea unui standard numit Common Language Infrastructure (http://www.ecmainternational.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 programe, oferã acces uºor la baze de date, permite realizarea desenelor sau a altor elemente grafice. Spaþiul de nume System.Windows.Forms conþine instrumente (controale) 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 predefinite. 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 corespunzã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 editor de text, fiºierele se salveazã cu extensia cs, apoi se compileazã la linie de comandã. Astfel, se scrie în Notepad programul:
using System; class primul { static void Main() { Console.WriteLine(“Primul program”); Console.ReadKey(true); } }

26

Introducere în .Net Framework (Suport de curs)

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. Dacã se

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, introducem 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 întrerupere (Toggle Breakpoint F9 pe linia respectivã ºi apoi Start Debugging F5). Încetarea urmãririi pas cu pas (Stop Debugging Shift+F5) permite ieºirea din modul depanare ºi revenirea la modul normal de lucru. Toate opþiunile de rulare ºi depanare se gãsesc în meniul Debug al mediului.

Fereastra de cod ºi ferestrele auxiliare ce ne ajutã în etapa de editare pot fi vizualizate alegând opþiunea corespunzãtoare din meniul View. Ferestrele auxiliare utile în etapa de depanare se pot vizualiza alegând opþiunea corespunzãtoare din meniul Debug/Windows.

3.4. Structura unui program C#
Sã începem cu exemplul clasic “Hello World” adaptat la limbajul C#:
1 2 3 4 5 6 7 8 9 10 11 12 using System; namespace HelloWorld { class Program { static void Main() { Console.WriteLine(“Hello World!”); } } }

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 definite î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-

28

Introducere în .Net Framework (Suport de curs)

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 completã 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 format 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"

CAPITOLUL 3. Limbajul C#

29

// 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 /* reprezintã începutul comentariului, iar */ sfârºitul respectivului comentariu.
/* Acesta este un comentariu care se intinde pe mai multe randuri */

Nume Prin nume dat unei variabile, clase, metode etc. înþelegem o succesiune de caractere care îndeplineºte urmãtoarele reguli: • numele trebuie sã înceapã cu o literã sau cu unul dintre 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 byte class delegate event fixed if internal new override readonly short struct try unsafe volatile as case const do explicit float implicit is null params ref sizeof switch typeof ushort while base catch continue double extern for in lock object private return stackalloc this uint using bool char decimal else false foreach int long operator protected sbyte static throw ulong virtual break checked default enum finally goto interface namespace out public sealed string true unchecked void

Simbolurile lexicale reprezentând constante, regulile de formare a expresiilor, separatorii de liste, delimitatorii de instrucþiuni, de blocuri de instrucþiuni, de ºiruri de caractere etc. sunt în mare aceiaºi ca ºi în cazul limbajului C++.

30

Introducere în .Net Framework (Suport de curs)

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ândul ei din clasa Object (alias pentru System.Object). Limbajul C# conþine un set de tipuri predefinite (int, bool etc.) ºi permite definirea unor tipuri proprii (enum, struct, class etc.). Tipuri simple predefinite
Tip object string sbyte short int long byte ushort uint ulong float double bool char decimal Descriere rãdãcina oricãrui tip secvenþã de caractere Unicode tip întreg cu semn, pe 8 biþi tip întreg cu semn, pe 16 biþi tip întreg cu semn pe, 32 biþi tip întreg cu semn, pe 64 de biþi tip întreg fãrã semn, pe 8 biþi tip întreg fãrã semn, pe 16 biþi tip întreg fãrã semn, pe 32 biþi tip întreg fãrã semn, pe 64 biþi -128; 127 -32768; 32767 -2147483648; 21447483647 -9223372036854775808; 9223372036854775807 0; 255 0; 65535 0; 4294967295 0; 18446744073709551615 Domeniul de valori

tip cu virgulã mobilã, simplã precizie, pe 32 biþi -3.402823E+38; 3.402823E+38 (8 pentru exponent, 24 pentru mantisã) tip cu virgulã mobilã, dublã precizie, pe 64 biþi (11 pentru exponent, 53 -mantisa) tip boolean tip caracter din setul Unicode, pe 16 biþi tip zecimal, pe 128 biþi (96 pentru mantisã), 28 de cifre semnificative -1.79769313486232E+308; 1.79769313486232E+308 -79228162514264337593543950335; 79228162514264337593543950335

CAPITOLUL 3. Limbajul C#

31

O valoare se asigneazã dupã urmãtoarele reguli:
Sufix nu are u, U L, L ul, lu, Ul, lU, UL, LU, Lu Exemple: string s = "Salut!" long a = 10; long b = 13L; ulong c = 12; ulong d = 15U; ulong e = 16L; ulong f = 17UL; float g = 1.234F; double h = 1.234; double i = 1.234D; bool cond1 = true; bool cond2 = false; decimal j = 1.234M; Tip int, uint, long, ulong uint, ulong long, ulong ulong

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 variabilã 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 }

32

Introducere în .Net Framework (Suport de curs)

Exemplu:
using System; namespace tipulEnum { class Program { enum lunaAnului { Ianuarie = 1, Februarie, Martie, Aprilie, Mai, Iunie, Iulie, August, Septembrie, Octombrie, Noiembrie, Decembrie } static void Main(string[] args) { Console.WriteLine(“Luna Mai este a {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 regulate ºi tablouri neregulate (tablouri de tablouri) Declarare în cazul tablourilor regulate bidimensionale:
Tip[,] nume;

Intanþiere:
nume = new Tip[Linii,Coloane];

Acces:
nume[indice1,indice2]

CAPITOLUL 3. Limbajul C#

33

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 \' \" \\ \0 \a \b \f \n \r \t \u \v \x Efect apostrof ghilimele backslash null alarmã backspace form feed - paginã nouã new line - linie nouã carriage return - început de rând horizontal tab - tab orizontal caracter unicode vertical tab - tab vertical caracter hexazecimal

34

Introducere în .Net Framework (Suport de curs)

În cazul în care folosim multe secvenþe escape, putem utiliza ºirurile verbatim. Aceste ºiruri pot sã conþinã orice fel de caractere, inclusiv caracterul EOLN. Ele se folosesc în special în cazul în care dorim sã facem referiri la fiºiere ºi la regiºtri. Un astfel de ºir începe întotdeauna cu simbolul’@’ înaintea ghilimelelor de început. Exemplu:
using System; namespace SiruriDeCaractere { class Program { static void Main(string[] args) { string a = “un sir de caractere”; string b = “linia unu \nlinia doi”; string c = @”linia unu linia doi”; string d=”c:\\exemple\\unu.cs”; string e = @”c:\exemple\unu.cs”; Console.WriteLine(a); Console.WriteLine(b); Console.WriteLine(c); Console.WriteLine(d); Console.WriteLine(e); Console.ReadLine(); } } }

Programul va avea ieºirea
un sir de caractere linia unu linia doi linia unu linia doi c:\exemple\unu.cs c:\exemple\unu.cs

3.7. Conversii
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ã.

CAPITOLUL 3. Limbajul C#

35

Exemplu:
using System; using System.Collections.Generic; using System.Text; namespace Conversii { class Program { static void Main(string[] args) { 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 sbyte byte short ushort int uint long char float ulong în short, int, long, float, double, decimal short, ushort, int, uint, long, ulong, float, double, decimal int, long, float, double, decimal int, uint, long, ulong, float, double, decimal long, float, double, decimal long, ulong, float, double, decimal float, double, decimal ushort, int, uint, long, ulong, float, double, decimal double 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 {

36

Introducere în .Net Framework (Suport de curs)

class Program { static void Main(string[] args) { 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 sbyte byte short ushort int uint long ulong char float double în byte, ushort, uint, ulong, char sbyte, char sbyte, byte, ushort, uint, ulong, char sbyte, byte, short, char sbyte, byte, short, ushort, uint, ulong, char sbyte,byte, short, ushort, int, char sbyte, byte, short, ushort, int, uint, ulong, char sbyte, byte, short, ushort, int, uint, long, char sbyte, byte, short sbyte, byte, short, ushort, int, uint, long, ulong, char, decimal 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 caractere. Sintaxa pentru conversia unui numãr în ºir de caractere: numãr → ºir “” + numãr

sau se foloseºte metoda ToString a clasei Object.

CAPITOLUL 3. Limbajul C#

37

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

Observaþie: în cazul în care ºirul de caractere nu reprezintã un numãr valid, conversia acesui ºir la numãr va eºua. Exemplu:
using System; namespace Conversii { class Program { static void Main(string[] args) { 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);

38

Introducere în .Net Framework (Suport de curs)

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. ——————————— int 13 long 100000 float 2,15 double 3,1415 STRING VAL. ——————————— 13 13 1000 1000 2,15 2,15 3.1415 3,1415

STRING 13 100000 2,15 3,1415 TIP int long float 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 boxing 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; i = (int)ob; //boxing implicit //unboxing explicit

CAPITOLUL 3. Limbajul C#

39

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þializate la declararea lor. Exemple:
const int x; const int x = 13; //gresit, constanta nu a fost initializata //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 operator este un simbol ce indicã acþiunea care se efectueazã, iar operandul este valoarea asupra cãreia se executã operaþia. În C# sunt definiþi mai mulþi operatori. În cazul în care într-o expresie nu intervin paranteze, operaþiile se executã conform prioritãþii 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 0 1 2 3 4 5 6 7 8 9 10 11 12 13 Primar Unar Multiplicativ Aditiv De deplasare Relaþional De egalitate AND (SI) logic OR (SAU) logic AND (SI) condiþional OR (SAU) condiþional Condiþional De atribuire Operatori ( ) [ ] f() . x++ x-- new typeof sizeof checked unchecked -> + - ! ~ ++x --x (tip) true false & sizeof * / % + << >> < > <= >= is as == != & | && || ?: = *= /= %= += -= ^= &= <<= >>= |= Asociativitate

→ → → → → → → → → → → →
← ←

XOR (SAU exclusiv) logic ^

40

Introducere în .Net Framework (Suport de curs)

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 { static void Main(string[] args) { 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;

CAPITOLUL 3. Limbajul C#

41

namespace Test { class Program { static void Main(string[] args) { 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 { static void Main(string[] args) { int n = 0; do { Console.WriteLine(“n este {0}”, n); n++; } while (n <= 10); Console.ReadLine(); } }

}

42

Introducere în .Net Framework (Suport de curs)

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 pozitive <=10
using System; namespace Test { class Program { static void Main(string[] args) { for(int n=0; n<=10; n++) { Console.WriteLine(“n este {0}”, 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 posibilitatea 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 comparatã cu ºirurile de caractere din case-uri.

CAPITOLUL 3. Limbajul C#

43

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þiune 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 valoarea. 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.

44

Introducere în .Net Framework (Suport de curs)

Exemplu:
using System; namespace Salt { class Program { static void Main(string[] args) { 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;

CAPITOLUL 3. Limbajul C#

45

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 termine 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 { static void Main(string[] args) { 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(); } } } }

46

Introducere în .Net Framework (Suport de curs)

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 &.

48

Introducere în .Net Framework (Suport de curs)

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þiunea 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 paginã, 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 obiectul 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>&nbsp;<br /> <input type=”submit” name=”Button1” value=”Button” id=”Button1” style=”zindex: 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 fereastra Solution Explorer selectaþi Start.aspx ºi apoi butonul View in Browser".

50

Introducere în .Net Framework (Suport de curs)

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 checkbox º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 checkbox 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ã

CAPITOLUL 4. Programarea web cu ASP.NET

51

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”; } protected void Button1_Click(object sender, EventArgs e) { 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:
protected void Page_Load(object sender, EventArgs e) { 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 executã 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

52

Introducere în .Net Framework (Suport de curs)

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”); protected void Page_Load(object sender, EventArgs e) { if (Page.IsPostBack == false) { ViewState.Add(“ViewStateTest”, “Hello”); } }

Regãsirea datelor se realizeazã folosind ca indice numele obiectului:
protected void Button1_Click(object sender, EventArgs e) { 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âmplã 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ã:

CAPITOLUL 4. Programarea web cu ASP.NET

53

<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:
protected void Button1_Click(object sender, EventArgs e) { Session[“sir”] = test; }

Session este de fapt un dicþionar (listã de perechi cheie – valoare), în care valorile sunt de tip object. Ceea ce înseamnã cã la citirea unor valori din sesiune va trebui sã realizãm o conversie de tip.
protected void Button2_Click(object sender, EventArgs e) { 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

54

Introducere în .Net Framework (Suport de curs)

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 dimensiuni 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 pentru 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

CAPITOLUL 4. Programarea web cu ASP.NET

55

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 (prorietatea 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 valoare 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 securitate 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 contului respectiv. Aplicaþie web disponibilã pe Internet, dar Windows Integrated cu acces privat. Aplicaþii web comerciale. Forms Authentication Utilizatorii companiei pot accesa aplicaþia din afara Intranetului, folosind conturi din lista serverului (Domain Controller). Aplicaþii care au nevoie de informaþii confidenþiale ºi eventual în care sunt mai multe tipuri de utilizatori.

56

Introducere în .Net Framework (Suport de curs)

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 utilizatorului 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ã autentificarea, 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 clientului º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ã securizatã 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) autentificarea º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.

CAPITOLUL 4. Programarea web cu ASP.NET

57

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 programare 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 programul. 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 controale, 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 aplicaþii relativ mici sau cu multe operaþii de acces (in/out) la o bazã de date. b)Modelul arhitectural Model-view-controller Este caracterizat de cele trei concepte de bazã: Model (reprezentarea datelor se realizeazã într-o manierã specificã aplicaþiei: conþine 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”, eveniment 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.

60

Introducere în .Net Framework (Suport de curs)

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 respectate º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 („tem30 Î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 template Windows Application. O aplicaþie Windows conþine cel puþin o fereastrã (Form) în care se poate crea o interfaþã cu utilizatorul aplicaþiei. Componentele vizuale ale aplicaþiei pot fi prelucrate în modul Designer (Shift+F7) pentru a plasa noi obiecte, a le stabili proprietãþile etc. Codul ”din spatele” unei componente 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 imaginea alãturatã.

Designer, Code, Solution Explorer ºi celelalte se aflã grupate în meniul View. La crearea unei noi aplicaþii vizuale, Visual Studio.NET 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

62

Introducere în .Net Framework (Suport de curs)

statice. Metoda Run invocatã mai sus creeazã un formular implicit, aplicaþia rãspunzând la mesajele utilizatorului pânã când formularul va fi închis. Compilarea modulelor aplicaþiei ºi asamblarea lor într-un singur fiºier ”executabil” 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 procesului 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 realizeazã: derivarea unei clase proprii din System.Windows.Forms.Form, clasã care este înzestratã cu o colecþie de controale (iniþial vidã). Constructorul ferestrei realizeazã instanþieri ale claselor Button, MenuStrip, Timer etc. (orice plasãm noi în fereastrã) ºi adaugã referinþele acestor obiecte la colecþia de controale ale ferestrei. Dacã modelul de fereastrã reprezintã ferestra principalã a 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 formularului deschis modal. Când un nou formular este activat folosind form.Show() nu va avea nici un deþinãtor, acesta stabilindu-se direct:
public Form Owner { get; set; } F_nou form=new F_nou(); form.Owner = this; form.Show();

Formularul deschis modal va avea un proprietar setat pe null. Deþinãtorul se poate stabili setând proprietarul înainte sã apelãm Form.ShowDialog() sau apelând

CAPITOLUL 5. Programare vizualã

63

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ã proprietãþ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 întregului 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

64

Introducere în .Net Framework (Suport de curs)

• • • • • • •

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 formularul 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 evenimentul implicit este Click, pentru TextBox este TextChanged, pentru un formular Load etc.). Printre evenimentele cele mai des utilizate, se numãrã : • Load apare când formularul este pentru prima data încãrcat în memorie. • FormClosed apare când formularul este închis. • FormClosing apare când formularul se va inchide ca rezultat al acþiunii utilizatorului 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.

CAPITOLUL 5. Programare vizualã

65

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 proprietãþ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 calendar casetã de validare etichetã casetã cu listã imagine pointer buton radio casetã de text MonthCalendar CheckBox Label ListBox PictureBox Pointer RadioButton TextBox Afiºeazã implicit un mic calendar al lunii curente. Acesta poate fi derulat ºi înainte ºi înapoi la celelalte luni calendaristice. Oferã utilizatorului opþiunile : da/nu sau include/exclude Sunt folosite pentru afiºarea etichetelor de text, ºi a pentru a eticheta controalele. Afiºeazã o listã de articole din care utilizatorul poate alege. Este folosit pentru adãugarea imaginilor sau a altor resurse de tip bitmap. Este utilizat pentru selectarea, mutarea sau redimensionarea unui control. Este folosit pentru ca utilizatorul sã selecteze un singur element dint-un grup de selecþii. Este utilizat pentru afiºarea textului generat de o aplicaþie 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 fereastra 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 textului din formular, iar cea de a doua seteazã culoarea formularului. Toate acestea le puteþi modifica dupã preferinþe din fereastra Properties.

66

Introducere în .Net Framework (Suport de curs)

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 controlului. 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 formular pentru a ajunge la administratorul sãu de evenimente. Editaþi administratorul evenimentului conform exemplului de mai jos:

CAPITOLUL 5. Programare vizualã

67

private void button1_Click(object sender, EventArgs e) { 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.
private void button1_Click(object sender, EventArgs e) { string a = “PLATFORMA .NET”; textBox1.Text = a; }

Casete de mesaje: Pentru a crea o casetã mesaj, apelãm metoda MessageBox.Show();.Într-o nouã aplicaþ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

68

Introducere în .Net Framework (Suport de curs)

adãugaþi în administratorul evenimentului Click linia de program: MessageBox.Show(“tiam 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 proprietatea 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.
private void button1_Click(object sender, EventArgs e) { 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 proprietatea 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 executaþi dublu clic pe butonul OK ºi folosiþi urmãtorul cod pentru administratorul evenimentului Click:
private void button1_Click(object sender, EventArgs e) { textBoxText = textBox1.Text; this.Close(); }

CAPITOLUL 5. Programare vizualã

69

Executaþi dublu clic pe butonul Cancel ºi folosiþi urmãtorul cod pentru administratorul evenimentului Click:
private void button2_Click(object sender, EventArgs e) { 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 modificaþi fiecare sursã respectând codul de mai jos:
private void button7_Click(object sender, EventArgs e) { string v = textBox1.Text; v += “7”; textBox1.Text = v; }

70

Introducere în .Net Framework (Suport de curs)

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 -.
private void button11_Click(object sender, EventArgs e) { op1 = textBox1.Text; operatie = “+”; textBox1.Text = “”; }

Pentru butonul = folosiþi codul urmãtor:
private void button13_Click(object sender, EventArgs e) { 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.

CAPITOLUL 5. Programare vizualã

71

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 pentru cele douã butoane:
private void { private void { button1_Click(object sender, System.EventArgs e) MessageBox.Show(textBox1.Text);} button2_Click(object sender, System.EventArgs e) Form1.ActiveForm.Dispose();}

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

Dupã adãugarea butoanelor ºi a casetei text pe formular, stabilim evenimentele care determinã schimbarea culoriilor ºi completarea casetei text.

72

Introducere în .Net Framework (Suport de curs)

private void button1_Click(object sender, System.EventArgs e) {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;} private void button4_Click(object sender, System.EventArgs e) {textBox1.Visible=true;textBox1.Text=””; if( button1.BackColor==Color.Yellow)textBox1.Text=textBox1.Text+’A’; if( button2.BackColor==Color.Yellow)textBox1.Text=textBox1.Text+’B’; if( button3.BackColor==Color.Yellow)textBox1.Text=textBox1.Text+’C’; }

Exerciþiu Modificaþi aplicaþia precedentã astfel încât sã avem un singur eveniment button_Click, diferenþierea fiind fãcutã de parametrul sender. Exerciþiu ( Password) Adãugaþi pe un formular o casetã text în care sã introduceþi un ºir de caractere ºi apoi verificaþi dacã acesta coincide cu o 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 controlului. Aplicaþia PV3 este un exemplu de utilizare a acestor controale. Soluþia unei probleme cu mai multe variante de rãspuns este memoratã cu ajutorul unor checkbox-uri cu proprietatea ThreeState. Apãsarea butonului Verificã determinã afiºarea unei etichete ºi a butoanelor radio DA ºi NU. Rãspunsul este afiºat într-un 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:

CAPITOLUL 5. Programare vizualã

73

private void radioButton1_Click(object sender, System.EventArgs e) {if (checkBox1.CheckState==CheckState.Checked && checkBox2.CheckState==CheckState.Checked && checkBox3.CheckState==CheckState.Checked && checkBox5.CheckState==CheckState.Checked && checkBox4.CheckState==CheckState.Unchecked) MessageBox.Show(“CORECT”); else MessageBox.Show(“Indicatie> Daca punem un sac in altul....”); label2.Visible=false; radioButton1.Checked=false; radioButton2.Checked=false; radioButton1.Visible=false; radioButton2.Visible=false;} private void button1_Click(object sender, System.EventArgs e) {label2.Visible=true;radioButton1.Visible=true;radioButton2.Visible=true;}

Exerciþiu (Test grilã) Construiþi un test grilã care conþine 5 itemi cu câte 4 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 trebuie 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, LinkLabelLinkClickedEventArgs e ) {etichetaI.LinkVisited = true; System.Diagnostics.Process.Start(“IExplore”, “http://www.microsoft.com/romania/” );} private void etichetaN_LinkClicked( object sender, LinkLabelLinkClickedEventArgs e ) {etichetaN.LinkVisited = true; System.Diagnostics.Process.Start( “notepad” );}

74

Introducere în .Net Framework (Suport de curs)

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.

CAPITOLUL 5. Programare vizualã

75

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:

76

Introducere în .Net Framework (Suport de curs)

private void monthCalendar1_DateSelected(object sender, System.Windows.Forms.DateRangeEventArgs e) { this.label1.Text = “Interval selectat: Start = “ +e.Start.ToShortDateString() + “ : End = “ + e.End.ToShortDateString(); if (e.Start.ToShortDateString()==e.End.ToShortDateString()) {String x=e.Start.ToShortDateString(); if(!(comboBox1.Items.Contains(x))) comboBox1.Items.Add(e.End.ToShortDateString());} }

• DateTimePicker este un control care (ca ºi MonthCalendar) se poate utiliza pentru a selecta o datã. La clic se afiºeazã un control de tip MonthCalendar, prin care se poate selecta data doritã. Fiind foarte asemãnãtor cu MonthCalendar, proprietãþile prin care se poate modifica comportamentul controlului sunt identice cu cele ale controlului MonthControl. Exerciþiu (Formular) Contruiþi un formular de introducere a datelor necesare realizãrii unei adrese de e-mail. Data naºterii va fi selectatã direct 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 grafic 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); }

CAPITOLUL 5. Programare vizualã

77

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 folderelor):
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.

78

Introducere în .Net Framework (Suport de curs)

Observãm cã aducând din Toolbox controlul Timer, acesta nu se afiºeazã pe formular, 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 (Name) aplCeas Enabled True

Explicaþie Activarea controlului de timp Numãrul de milisecunde dintre apelurile la metoda de tratare a evenimentului. Se stabileºte, în cazul de faþã numãrãtoarea din secundã în secundã

Interval

1.000

Aducem în formular un control Label cu urmãtoarele proprietãþi:
Control label1 Proprietate (Name) AutoSize BorderStyle FontSize Location Text Size TextAlign Valoare labelCeas False Fixed3D 16,25, Bold 82;112 129;42 MiddleCenter

Dãm clic pe icoana de la timer care are numele aplCeas, iar la Events, la Tick selectãm lblCeas_Click

CAPITOLUL 5. Programare vizualã

79

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 control Button. Tabelul de mai jos descrie proprietãþile ºi valorile formularului ºi a respectivelor controale:

Formularul:
Control Form1 Proprietate (Name) Size BorderStyle Text Valoare Form1 606;265 Fixed3D Afiºare timp cu ProgressBar si Label

ProgressBar-urile:
Control ProgressBar1 Proprietate (Name) Location Maximum Size Step Style Valoare prgOre 82;64 23 431;23 1 Blocks

80

Introducere în .Net Framework (Suport de curs)

Control ProgressBar2

ProgressBar3

Proprietate (Name) Location Maximum Size Step Style (Name) Location Maximum Size Step Style

Valoare prgMinute 82;106 59 431;23 1 Blocks prgSecunde 82;144 59 431;23 1 Blocks

Pentru afiºarea textelor „Ore”, „Minute”, „Secunde” folosim:
Control Label1 Proprietate (name) Autosize BorderStyle Locations Size Text TextAlign (name) Autosize BorderStyle Locations Size Text TextAlign (name) Autosize BorderStyle Locations Size Text TextAlign Valoare lblOre False None 22;64 54;23 Ore MiddleLeft lblMinute False None 22;104 54;23 Minute MiddleLeft lblSecunde False None 22;144 54;23 Minute MiddleLeft

Label2

Label3

Pentru „Ieºire” folosim:
Control Button1 Proprietate (Name) Location Size Text Valoare btnIesire 25;198 75;23 Iesire

CAPITOLUL 5. Programare vizualã

81

Pentru informaþiile din partea dreaptã a formularului:
Control Label4 Proprietate (name) Autosize Locations Size Text TextAlign (name) Autosize BorderStyle Locations Size Text TextAlign (name) Autosize BorderStyle Locations Size Text TextAlign (name) Autosize BorderStyle Locations Size Text TextAlign Valoare lblTextTimp False 523;10 54;23 Timp MiddleCenter lblAfisOre False Fixed3D 523;64 54;23 00 MiddleCenter lblAfisMinute False Fixed3D 523;106 54;23 00 MiddleCenter lblAfisSecunde False Fixed3D 523;144 54;23 00 MiddleCenter

Label5

Label6

Label4

Pentru Timer:
Control Timer1 Proprietate (Name) Enabled Interval Valoare Timer1 True 1.000 Evenimente Timer1_Tick

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();

82

Introducere în .Net Framework (Suport de curs)

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 parametru un obiect de tip ToolBarButtonClickEventArgs, prin care programatorul are acces la butonul care a fost apasat). În aplicaþia urmãtoare PV9 cele 3 butoane ale toolbar-ului permit modificarea proprietãþilor textului introdus în casetã. Toolbar-ul se poate muta fãrã a depãºi spaþiul ferestrei. Schimbarea fontului se realizeazã cu ajutorul unui control FontDialog(),iar schimbarea culorii utilizeazã ColorDialog()
FontDialog fd = new FontDialog(); fd.ShowColor = true;fd.Color = Color.IndianRed; fd.ShowApply = true; fd.Apply += new EventHandler(ApplyFont); if(fd.ShowDialog() != System.Windows.Forms.DialogResult.Cancel)

CAPITOLUL 5. Programare vizualã

83

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

84

Introducere în .Net Framework (Suport de curs)

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 multor obiecte. Ultima paginã reprezintã coºul de cumpãrãturi. • Grupuri de controale tip Meniu (MenuStrip, ContextMenuStrip etc.) Un formular poate afiºa un singur meniu principal la un moment dat, meniul asociat iniþial fiind specificat prin propietatea Form.MainMenuStrip. Meniul care este afiºat de cãtre un formular poate fi schimbat dinamic la rulare:
switch(cond) { case cond1:this.MainMenuStrip = this.mainMenu1;break; case cond2:this.MainMenuStrip = this.mainMenu2; }

unde mainMenu1 ºi mainMenu2 sunt obiecte de tip MenuStrip. Editarea unui astfel de obiect se poate face utilizând Menu Designer. Clasa MenuStrip are o colecþie de MenuItem care conþine 0 sau mai multe obiecte de tip MenuItem. Fiecare dintre aceste obiecte de tip MenuItem are 0 sau mai multe obiecte de tip MenuItem, care vor constitui noul nivel de itemi (Ex: File New,Save, Open, Close, Exit). Propietãþile Checked º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

CAPITOLUL 5. Programare vizualã

85

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.

86

Introducere în .Net Framework (Suport de curs)

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 program un punct dintr-un anumit spaþiu. De exemplu, pentru a modifica poziþia unui buton în fereastrã putem asigna un obiect de tip Point proprietãþii Location indicând astfel poziþia colþului din stânga-sus al butonului (button.Location = new Point(100, 30)). Putem construi un obiect de tip Point pentru a redimensiona un alt obiect.
Size mySize = new Size(15, 100); Point myPoint = new Point(mySize); System.Console.WriteLine(“X: “ + myPoint.X + “, Y: “ + myPoint.Y);

Structura Color conþine date, tipuri ºi metode utile în lucrul cu culori. 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)))

CAPITOLUL 5. Programare vizualã

87

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 primarã a problemei. Validarea la nivel de câmp Datele pot fi validate pe mãsurã ce sunt introduse, asociind o prelucrare unuia

88

Introducere în .Net Framework (Suport de curs)

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, evenimentele 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 determinã utilizarea optimã a resurselor.

90

Introducere în .Net Framework (Suport de curs)

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 pentru 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
using System.Data.SqlClient; 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 permite 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 Provider Data Source Initial Catalog Descriere Specificã furnizorul de date pentru conectarea la sursa de date. Acest furnizor 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, un domeniu sau o adresa IP. specificã numele bazei de date. Baza de date trebuie sã se gãseascã pe serverul dat în Data Source

Integrated Security32 Logarea se face cu user-ul configurat pentru Windows. User ID Password Numele unui user care are acces de logare pe server Parola corespunzãtoare ID-ului specificat.

b) ConnectionTimeout (int, cu accesor de tip get): specificã numãrul de secunde pentru care un obiect de conexiune poate sã aºtepte pentru realizarea conectãrii la
32 User Id ºi Password pot înlocui parametrul Integrated Security

92

Introducere în .Net Framework (Suport de curs)

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 pentru 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ã asociatã conexiunii curente.

6.3.4. Evenimente
a) StateChange: apare atunci când se schimbã starea conexiunii. Handlerul corespunzã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.

CAPITOLUL 6. ADO.NET

93

6.4.1. Proprietãþi
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}”,

94

Introducere în .Net Framework (Suport de curs)

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:
using System.Data.SqlClient; SqlConnection conn = new SqlConnection(@”Data Source=serverBD;Database=MAGAZIN;User ID=adm;Password=eu”); conn.Open();

CAPITOLUL 6. ADO.NET

95

º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 obiectul 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 Stabilim conexiunea SqlCommand cmd = new SqlCommand(updateString);

96

Introducere în .Net Framework (Suport de curs)

cmd.Connection = conn;33 // Apelãm ExecuteNonQuery pentru executarea comenzii cmd.ExecuteNonQuery();

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 cmd.ExecuteNonQuery();

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; using System.Data.SqlClient; 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 obiectul 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

CAPITOLUL 6. ADO.NET

97

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; using System.Data.SqlClient; 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); rdr = cmd.ExecuteReader(); while (rdr.Read()) {Console.WriteLine(rdr[0]);} } finally { if (rdr != null){rdr.Close();}

98

Introducere în .Net Framework (Suport de curs)

if (conn != null){conn.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); cmd.ExecuteNonQuery(); } 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); cmd.Connection = conn; cmd.ExecuteNonQuery(); } finally {if (conn != null){conn.Close();} } } public void DeleteData() { try { conn.Open(); string deleteString = @”delete from PRODUSE where DENUMIRE_PRODUS = ‘BARBIE’”; SqlCommand cmd = new SqlCommand(); cmd.CommandText = deleteString; cmd.Connection = conn; cmd.ExecuteNonQuery(); } 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(); }

CAPITOLUL 6. ADO.NET

99

finally {if (conn != null){conn.Close();} } 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, conexiunea 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 înregistrare 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.

100

Introducere în .Net Framework (Suport de curs)

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 exemplul) 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 trebuie 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
SqlCommand cmd = new SqlCommand(“select * from PRODUSE”, conn); rdr = cmd.ExecuteReader(); while (rdr.Read()) {Console.WriteLine(rdr[0]);}

este echivalent cu
SqlCommand cmd = new SqlCommand(“select * from PRODUSE”, conn); rdr = cmd.ExecuteReader(); while (rdr.Read()){Console.WriteLine (rdr[“ID_PRODUS”]);

Exerciþiu. Afiºaþi conþinutul tabelei PRODUSE utilizând DataReader.

CAPITOLUL 6. ADO.NET

101

using System; using System.Data; using System.Data.SqlClient; 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”); SqlCommand cmd = new SqlCommand(“select * from PRODUSE”, conn); try { conn.Open(); rdr = cmd.ExecuteReader(); 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();} if (conn != null){conn.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 pentru transferul datelor. În exemplul urmãtor se preiau datele din tablele elevi ºi profi:
SqlDataAdapter de=new SqlDataAdapter(“SELECT nume,clasa FROM elevi”, conn); de.Fill(ds,”Elevi”);//transferã datele în datasetul ds sub forma unei tabele locale numite elevi SqlDataAdapter dp=new SqlDataAdapter(“SELECT nume, clasdir FROM profi”,conn);

102

Introducere în .Net Framework (Suport de curs)

dp.Fill(ds,”Profi”);//transferã datele în datasetul ds sub forma unei tabele locale numite profi

6.6.1. Proprietãþi
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ã popularea (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 combinaþ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ã.

CAPITOLUL 6. ADO.NET

103

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 conexiunea. 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 parametru (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, ...

104

Introducere în .Net Framework (Suport de curs)

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

CAPITOLUL 6. ADO.NET

105

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 parametri. O procedurã stocatã poate fi apelatã folosind obiectul SqlCommand:
SqlCommand cmd = new SqlCommand(“StoredProcedure1”, conn); cmd.CommandType = CommandType.StoredProcedure; //Tipul obiectului comanda este procedura 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 comanda 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 comanda 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 procedurii 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 biblioteci ºcolare.

106

Introducere în .Net Framework (Suport de curs)

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 prezentate. ”La vedere” se aflã controale de tip DataGridView, sau TableGridView, BindingNavigator etc. Meniul Data ºi fereastra auxiliarã Data Sources ne sunt foarte utile în lucrul cu surse de date externe.

Sã urmãrim un scenariu de realizare a unei aplicaþii simple cu o fereastrã în care putem vizualiza date dintr-o tabelã, putem 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

CAPITOLUL 6. ADO.NET

107

• 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 navigare 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 contextual cu lista principalelor operaþii ce se pot efectua cu obiectul respectiv.

Meniul contextual asociat grilei în care vor fi vizualizate datele permite configurarea modului de lucru cu grila (sursa de date, operaþiile permise ºi altele).

108

Introducere în .Net Framework (Suport de curs)

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

109

CAPITOLUL

7

MiniGhid Metodologic

39

I. Programa ºcolarã reper obligatoriu pentru un demers flexibil
Programa ºcolarã este parte a Curriculumului national. Termenul de curriculum derivã din limba latinã unde, printre altele înseamna drum cãtre. Programa ºcolarã descrie oferta educaþionalã a unei anumite discipline pentru un parcurs ºcolar determinat Filosofia contemporanã a educaþiei a evidenþiat diferenþa dintre o educaþie bazatã pe curriculum, adicã având ca element central la toate etajele sale activiatea de proiectare ºi programa analiticã, care are în centrul activitãþii didactice ideea de programare a traseului elevului cãtre un þel cunoscut ºi impus doar de cãtre adulþi. Conceptual, programele ºcolare actuale, se diferenþiazã de ,,programele analitice” prin accentul pe care îl pun pe interiorizarea unui mod de gândire specific fiecãrui domeniu transpus în ºcoalã prin intermediul unui obiect de studiu, nu pe succesiunea conþinuturilor ºi pe numãrul de ore alocat lor. Actualele programe ºcolare subliniazã importanþa rolului reglator al achiziþiilor elevilor în plan formativ. Centrarea pe competenþe reprezintã modalitatea care face ca sintagma centrarea pe elev sã nu rãmânã o lozincã fãrã conþinut. Proiectarea curriculumului pe competenþe vine în întâmpinarea cercetãrilor din psihologia cognitivã, conform cãrora prin competenþã se realizeazã în mod exemplar tranferul ºi mobilizarea cunoºtinþelor ºi a depriderilor în situaþii/contexte noi ºi dinamice. Modelul de proiectare curricularã centrat pe competenþe simplificã structura curriculumului ºi asigurã o mai mare eficienþã a proceselor de predare/învãþare ºi evaluare. Acesta permite operarea la toate nivelurile cu aceeaºi unitate: competenþa, în mãsurã sã orienteze demersurile agenþilor implicaþi în procesul de educaþie:
• • • • • • conceptorii de curriculum; specialiºtii în evaluare; profesorii; inspectorii; eleviii; pãrinþii.

39 În realizarea minighidului metodologic baza de documentare a constituit-o un set de lucrãri bibliografice, cãrora li s-au operat simplificãri, actualizãri, particularizãri ºi recomandãri, corelate cu curriculumul ºcolar în vigoare, în scopul operaþionalizãrii informaþiilor."

110

Introducere în .Net Framework (Suport de curs)

Fãrã a intra în detalii conceptuale, formulãm câteva definiþii de lucru necesare pentru explicarea manierei în care au fost concepute programele ºcolare. Definim competenþele ca fiind ansambluri structurate de cunoºtinþe ºi deprinderi dobândite prin învãþare; acestea permit identificarea ºi rezolvarea în contexte diverse a unor probleme caracteristice unui anumit domeniu. Structura programei ºcolare cuprinde: o notã de prezentare, competenþe generale, competenþe specifice ºi conþinuturi, valori ºi atitudini, sugestii metodologice. ♦ Competenþele generale se definesc pe obiect de studiu ºi se formeazã pe durata învãþãmântului liceal. Ele au un grad ridicat de generalitate ºi complexitate ºi au rolul de a orienta demersul didactic cãtre achiziþiile finale ale elevului. ♦ Competenþele specifice se definesc pe obiect de studiu ºi se formeazã pe parcursul unui an ºcolar. Ele sunt derivate din competenþele generale, fiind etape în dobândirea acestora. Competenþelor specifice li se asociazã prin programã unitãþi de conþinut. Componenta fundamentalã a programei este cea referitoare la competenþe specifice ºi conþinuturi. Pentru a asigura o marjã cât mai largã de acoperire a obiectelor de studiu, s-a pornit de la o diferenþiere cât mai finã a etapelor unui proces de învãþare. Acestora le corespund categorii de competenþe organizate în jurul câtorva verbe definitorii, ce exprimã complexe de operaþii mentale: 1. Receptarea - concretizatã prin urmãtoarele concepte operaþionale:
identificarea de termeni, relaþii, procese; observarea unor fenomene, procese; perceperea unor relaþii, conexiuni; nominalizarea unor concepte; culegerea de date din surse variate; definirea unor concepte. compararea unor date, stabilirea unor relaþii; calcularea unor rezultate parþiale; clasificarea datelor; reprezentarea unor date; sortarea-discriminarea; investigarea, descoperirea, explorarea; experimentarea. reducerea la o schemã sau model; anticiparea unor rezultate; remarcarea unor invarianþi; reprezentarea datelor rezolvarea de probleme prin modelare si algoritmizare. descrierea unor stãri, sisteme, procese, fenomene; generarea de idei; argumentarea unor enunþuri; demonstrarea.

2. Prelucrarea primarã (a datelor) - concretizatã prin urmãtoarele concepte operaþionale:

3. Algoritmizarea - concretizatã prin urmatoarele concepte operaþionale:

4. Exprimarea - concretizata prin urmatoarele concepte operaþionale:

CAPITOLUL 7. MiniGhid Metodologic

111

5. Prelucrarea secundarã (a rezultatelor) - concretizatã prin urmãtoarele concepte operaþionale:
compararea unor rezultate, date de ieºire, concluzii; calcularea, evaluarea unor rezultate; interpretarea rezultatelor; analiza de situaþii; elaborarea de strategii; relaþionãri între diferite tipuri de reprezentãri, între reprezentare ºi obiect. aplicarea în alte domenii; generalizarea ºi particularizarea; integrarea unor domenii; verificarea unor rezultate; optimizarea unor rezultate; transpunerea într-o altã sferã; negocierea; realizarea de conexiuni între rezultate; adaptarea ºi adecvarea la context.

6. Transferul, care poate fi concretizat prin urmatoarele concepte operaþionale:

Competenþele generale ce se urmãresc a fi formate la elevi pe parcursul treptei liceale de ºcolarizare precum ºi competenþele specifice fiecãrui an de studiu, derivate din acestea, se stabilesc pornind de la modelul de generare prin gruparea categoriilor de concepte operaþionale în funcþie de dominantele avute în vedere. ♦ Valorile ºi atitudinile apar în mod explicit sub forma unei liste separate in programa fiecãrui obiect de studiu. Ele acoperã întreg parcursul învãþãmantului liceal ºi orienteazã dimensiunile axioiogicã si afectiv-atitudinalã aferente formãrii personalitãþii din perspective fiecãrei discipline. Realizarea lor concretã derivã din activitatea didacticã permanentã a profesorului, constituind un implicit al acesteia. Valorile ºi atitudinile au o importanþã egalã în reglarea procesului educativ ca ºi competenþele - care acoperã dimensiunea cognitivã a personalitãþii - dar se supun altor criterii de organizare didactico-metodicã ºi de evaluare. ♦ Sugestiile metodologice cuprind recomandãri generale privind metodologia de aplicare a programei. Aceste recomandãri se pot referi la: − desfãºurarea efectivã a procesului de predare/învãþare, centrat pe formarea de competenþe: − identificarea celor mai adecvate metode ºi activitãþi de învãþare; − dotãri/materiale necesare pentru aplicarea în condiþii optime a programei; − evaluarea continuã. Dincolo de structura unitarã a programelor ºcolare, curriculumul naþional actual propune o ofertã flexibilã, ce permite profesorului adaptarea cadrului formal la personalitatea sa ºi la specificul clasei de elevi cu care lucreazã. Elementele care asigurã acest reglaj sunt: − posibilitatea intervenþiei profesorului în succesiunea elementelor de conþinut, cu condiþia asigurãrii coerenþei tematice ºi a respectãrii logicii interne a domeniului;

112

Introducere în .Net Framework (Suport de curs)

− lipsa prescrierii de la centru a intervalului de timp alocat elementelor de conþinut; − posibilitatea modificãrii, a completãrii sau a înlocuirii activitãþilor de învãþare, astfel încât acestea sã permitã un demers didactic personalizat.

II. Aplicarea programelor ºcolare
Existenþa unor programe centrate pe achiziþiile elevilor determinã un anumit sens al schimbãrii în didactica fiecãrei discipline. Tabelul de mai jos prezintã în antitezã caracteristici ale procesului de predare-învãþare din didactica tradiþionala ºi didactica actualã.
Strategii didactice Orientare tradiþionalã Urmãreºte prelegerea, expunerea, explicaþia profesorului. Încearcã sa reþinã ºi sa reproducã ideile auzite Acceptã în mod pasiv ideile transmise. Lucreazã izolat. Expune, þine prelegeri. Rolul profesorului Impune puncte de vedere. Se considerã ºi se manifestã în permanenþã "ca un pãrinte"'. Învãþarea are loc predominant prin memorare ºi reproducere de cunoºtinþe, prin apel doar la exemple "clasice", validate. Învãþarea conduce la competiþie între elevi, cu scopul de ierarhizare Vizeazã mãsurarea ºi aprecierea cunoºtinþelor (ce ºtie elevul). Evaluarea

Criterii

Orientare modernã Exprimã puncte de vedere proprii. Realizeazã un schimb de idei cu ceilalþi. Argumenteazã; pune ºi îºi pune întrebãri cu scopul de a înþelege, de a realiza sensul unor idei Coopereazã în rezolvarea problemelor ºi a sarcinilor de lucru. Faciliteazã ºi modereazã învãþarea. Ajutã elevii sã înþeleagã ºi sã explice punctele de vedere proprii. Este partener în învãþare. Învãþarea are loc predominant prin formare de competenþe ºi deprinderi practice. Învãþarea se realizeazã prin cooperare. Vizeazã mãsurarea ºi aprecierea competenþelor (ce poate sã facã elevul cu ceea ce ºtie).

Rolul elevului

Modul de realizare a învãþãrii

Pune accent pe aspectul cantitativ Pune accent pe elementele de ordin (cât de multã informaþie deþine elevul). calitativ (valori, atitudini). Vizeazã clasificarea "staticã" a elevilor, Vizeazã progresul în învãþare pentru fiecare elev.

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

CAPITOLUL 7. MiniGhid Metodologic

113

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

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

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

114

Introducere în .Net Framework (Suport de curs)

Unitatea ºcolarã………………… Disciplina………………………....

Profesor……....…………………….. Clasa/Nr. ore pe sãpt./ ……….....

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

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

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

CAPITOLUL 7. MiniGhid Metodologic

115

Unitatea ºcolarã………………… Disciplina………………………....

Profesor……....…………………….. Clasa/Nr. ore pe sãpt./ ……….....

Proiectul unitãþii de învãþare ………………………………….. Nr. de ore alocate ………………..
Conþinuturi Competenþe specifice Activitãþi de învãþare Resurse Evaluare Observatii

• Conþinuturi: apar inclusiv detalieri de conþinut necesare în explicitarea anumitor parcursuri, respectiv în cuplarea lor la baza proprie de cunoaºtere a elevilor. • În rubrica Competenþe specifice se trec simbolurile competenþelor specifice din programa ºcolarã • Activitãþile de învãþare pot fi cele din programa ºcolarã, completate, modificate sau chiar înlocuite de altele, pe care profesorul le considerã adecvate pentru atingerea obiectivelor propuse. • Rubrica Resurse cuprinde specificãri de timp, de loc, forme de organizare a clasei, material didactic folosit etc. • În rubrica Evaluare se menþioneazã instrumentele sau modalitaþile de evaluare aplicate la clasã. Finalul fiecãrei unitãþi de învãþare presupune Evaluare sumativã. Deºi denumirea ºi alocarea de timp pentru unitãþile de învãþare se stabilesc la începutul anului ºcolar prin planificare, este recomandabil ca proiectele unitaþilor de învãþare sã se completeze ritmic pe parcursul anului, având în avans un interval de timp optim pentru ca acestea sã reflecte cât mai bine realitatea. În completarea rubricaþiei, se urmãreºte corelarea elementelor celor cinci coloane. Practic pe baza indicaþiilor din planificare se fac detalierile pe orizontalã, ordonând activitãþile în succesiunea derulãrii, raportându-le la competenþe ºi specificând resursele necesare bunei desfãºurãri a procesului didactic. Proiectarea unitãþii de învãþare - ca ºi a lecþiei - începe prin parcurgerea schemei urmãtoare:

În ce scop voi face? Identificarea competenþelor

Ce voi face? Selectarea conþinuturilor

Cu ce voi face?

Cum voi face? Determinarea activitãþilor de învãþare

Cât s-a realizat? Stabilirea instrumentelor de evaluare

Analiza resurselor

ConceptuI de unitate de învãþare are rolul sã materializeze conceptul de demers didactic personalizat, flexibilizâd proiectarea didacticã ºi definind în acest sens pentru

116

Introducere în .Net Framework (Suport de curs)

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

III.4. Proiectarea activitãþii de evaluare se realizeazã concomitent cu proiectarea
demersului de predare/învãþare ºi în deplinã concordanþã cu acesta. Câteva întrebãri utile în proiectarea instrumentelor de evaluare sunt urmãtoarele: • Care sunt competenþele din programa ºcolarã, pe care trebuie sã le dobândeascã elevii? • Care sunt performanþele minime, medii ºi superioare pe care le pot atinge elevii, pentru a demonstra cã au atins aceste competenþe? • Care este specificul colectivului de elevi pentru care îmi propun evaluarea? • Când ºi în ce scop evaluez? • Pentru ce tipuri de evaluare optez? • Cu ce instrumente voi realiza evaluarea? • Cum voi proceda pentru ca fiecare elev sa fie evaluat prin tipuri de probe cât mai variate astfel încât evaluarea sã fie cât mai obiectivã? • Cum voi folosi datele oferite de instrumentele de evaluare administrate, pentru a elimina eventualele blocaje constatate în formarea elevilor ºi pentru a asigura progresul scolar al fiecãruia dintre ei?

CAPITOLUL 7. MiniGhid Metodologic

117

PREDICTIVÃ (INIÞIALÃ) TIPURI DE EVALUARE FORMATIVÃ (CONTINUÃ) SUMATIVÃ (FINALÃ)
• Probe scrise • Probe orale • Probe practice • • • • • • • Observarea sistematicã a elevilor Investigaþia Proiectul Portofoliul Tema pentru acasã Tema de lucru în clasã Autoevaluarea

TRADIÞIONALE METODE ªI INSTRUMENTE DE EVALUARE COMPLEMENTARE

Adeseori, evaluarea formativã este înlocuitã cu evaluarea curentã, în accepþiunea tradiþionalã de “notare ritmicã”, constând în probe stereotipe precum dictãri, calcule, compuneri, diverse tipuri de exerciþii etc., care sunt apreciate prin note în mod aproximativ, fãrã interes în ceea ce priveºte nivelul cognitiv, afectiv, psihomotor, relaþional. O astfel de evaluare are în vedere doar unele tipuri de comportamente, de obicei nerelevante pentru personalitatea elevului ºi neglijeazã aspecte importante ca: gândirea, imaginaþia, atitudinea de responsabilitate, adoptarea unor metode proprii de lucru, competenþa de comunicare ºi de relaþionare etc. Ceea ce este generalizat în evaluarea curentã din ºcoli este stocarea în memorie a abstracþiilor ºi promptitudinea reproducerii acestora. Multe cunoºtinþe ºi capacitãþi care necesitã evaluare sunt ignorate, deºi sunt, în egalã mãsurã, variabile importante ale învãþãrii, cum ar fi: atitudinea elevului faþã de învãþare, faþã de disciplina de studiu, faþã de educator ºi faþã de interrelaþiile din interiorul colectivului de elevi, modul în care elevul învaþã (sistematic sau sporadic), modul cum abordeazã cunoºtinþele pentru a rezolva probleme practice, specifice vieþii cotidiene etc. Focalizatã pe unitatea de învãþare, evaluarea ar trebui sã asigure evidenþierea progresului înregistrat de elev în raport cu sine însuºi, pe drumul atingerii competenþelor prevãzute în programã. Este important sã fie evaluatã nu numai cantitatea de informaþie de care dispune elevul, ci, mai ales, ceea ce poate el sã facã utilizând ceea ce ºtie sau ceea ce intuieºte. În acest sens, câteva aspecte pot fi avute în vedere: − modificarea raportului dintre evaluarea sumativã, care inventariazã, selecteazã ºi ierarhizeazã prin notã ºi evaluarea formativã, ce are drept scop valorificarea potenþialului de care dispun elevii ºi conduce la perfecþionarea continuã a stilului ºi a metodelor proprii de învãþare; − realizarea unui echilibru dinamic între evaluarea scrisã ºi evaluarea oralã: aceasta din urmã, deºi presupune un volum mare de timp pentru aprecierea tuturor

118

Introducere în .Net Framework (Suport de curs)

elevilor ºi blocaje datorate emoþiei sau timiditãþii, prezintã avantaje deosebite, ca: realizarea interacþiunii elev-profesor, demonstrarea comportamentului comunicativ ºi de inter-relaþionare a elevului. − folosirea cu mai mare frecvenþã a metodelor de autoevaluare ºi evaluare prin consultare în grupuri mici. În raport cu momentele realizãrii evaluãrii, în proiectul unitãþii de învãþare apar specificaþii: evaluare iniþialã, formativã sau sumativã. Fiecare activitate de evaluare a rezultatelor ºcolare trebuie însoþitã în mod sistematic de o autoevaluare a procesului pe care profesorul l-a desfãºurat cu toþi elevii ºi cu fiecare elev. Numai astfel pot fi stabilite modalitãþile prin care poate fi reglatã, de la o etapã la alta, activitatea de învãþare / formare a elevilor în mod diferenþiat.

III.4.1. Tipuri de itemi
Item = <întrebare> + <formatul acesteia> + <rãspunsul aºteptat>

Teoria ºi practica evaluãrii evidenþiazã mai multe citerii pe baza cãrora pot fi clasificaþi itemii. Unul dintre criteriile cel mai des utilizate este acela al gradului de obiectivitate oferit în corectare. În funcþie de acest criteriu, itemii pot fi clasificaþi în trei mari categorii: a. Itemii obiectivi asigurã un grad de obiectivitate ridicat în mãsurarea rezultatelor ºcolare ºi testeazã un numãr mare de elemente de conþinut într-un interval de timp relativ scurt. Rãspunsul aºteptat este bine determinat, ca ºi modalitatea de notare a acestuia. b. Itemii semiobiectivi permit ca rãspunsul aºteptat sã nu fie totdeauna unic determinat, modalitatea de corectare ºi notare inducând uneori mici diferenþe de la un corector la altul. Aceºtia testeazã o gamã mai variatã de capacitãþi intelectuale, oferind în acelaºi timp posibilitatea de a utiliza ºi materiale auxiliare în rezolvarea sarcinilor de lucru propuse. c. Itemii subiectivi (cu rãspuns deschis) solicitã un rãspuns amplu, permiþând valorificarea capacitãþilor creative ale elevilor. Aceºtia sunt relativ uºor de construit, principala problemã constituind-o modul de elaborare a schemei de notare astfel încât sã se poatã obþine unitate ºi uniformitate la nivelul corectãrii. d. Itemi obiectivi Fie cã este vorba de activitãþi de proiectare ºi programare (Informaticã), fie cã este vorba de activitãþi de utilizare ºi combinare a instrumentelor informatice (Tehnologia Informaþiei), lucrul cu calculatorul implicã formulãri standardizate, lipsite de echivoc, itemii obiectivi ºi cei semiobiectivi repezentând instrumente de evaluare fracvent aplicate la aceste discipline. Itemii obiectivi sunt caracterizaþi prin:

CAPITOLUL 7. MiniGhid Metodologic

119

♦ structurarea sarcinilor propuse ºi standardizarea formatului lor de prezentare; ♦ corelarea strictã a sarcinilor cu obiectivele de evaluãrii; ♦ capacitatea de a testa un numãr mare de elemente de conþinut într-un timp relativ scurt; ♦ obiectivitate privind aprecierea rãspunsului; ♦ posibilitatea asocierii cu un sistem de notare extrem de simplu: punctajul aferent se acordã integral, se acordã parþial conform unei reguli (formule) de calcul sau nu se acordã deloc (în funcþie de rãspunsul aºteptat); ♦ rolul secundar pe care îl au de a obiºnui elevul cu formulãri standard, ºtiinþifice, elemente utile în construirea rãspunsurilor pentru itemii semiobiectivi ºi subiectivi. a.1. Itemi cu alegere dualã Alegerea dualã presupune formularea unei cerinþe cu douã variante complementare de rãspuns (Adevãrat/Fals, Da/Nu, Corect/Incorect etc.). Se pot verifica prin intermediul itemilor cu alegere dualã: − cunoºtinþele legate de corectitudinea sintacticã a unor expresii (comenzi, instrucþiuni, notaþii etc.); − înþelegerea semnificaþiei unor noþiuni din terminologia de specialitate (denumiri, instrumente de prelucrare, metode de rezolvare, proprietãþi etc.) − recunoaºterea unor explicaþii, definiþii, sau imagini. Itemii de acest tip se prezintã sub forma unor întrebãri sau enunþuri, efortul elevului reducându-se la identificarea unui rãspuns din douã posibile. Achiziþiile evaluate prin itemii cu alegere dualã sunt de regulã rudimentare. Fac excepþie enunþurile care pun în evidenþã justificãri ale unor proprietãþi, operaþii sau reguli, justificãri care necesitã achiziþii cognitive superioare. Tot în categoria itemilor cu alegere dualã se pot realiza cerinþe care necesitã din partea elevului operaþii de anticipare a efectului unei operaþii prin aplicarea unui sistem riguros de cunoºtinþe într-un context nou. Aceºtia sunt itemii cu cel mai înalt grad de dificultate. Atragem atenþia asupra faptului cã lipsa “firului roºu“ care pune în evidenþã elementele sistematice întâlnite în utilizarea unui produs soft (chiar ºi în cazul unui soft de bazã) conduc la un experimentalism accentuat care împiedicã formarea capacitãþii elevului de a se adapta situaþiilor noi, neexersate. Factorul de discriminare fiind însã extrem de mic, elevul va putea obþine un rezultat acceptabil la un test format numai din astfel de itemi alegând la întâmplare un rãspuns dintre cele douã admise pentru fiecare item în parte. De obicei, itemii cu alegere dualã sunt formulaþi în combinaþie cu itemi subiectivi de tipul “Justificaþi...”, “Scrieþi varianta corectã...”, “Explicaþi în ce constã eroarea...“ etc. În aceste cazuri, o parte din punctaj este alocatã justificãrii. Pentru proiectarea corectã a itemilor cu alegere dualã este necesarã respectarea urmãtoarelor cerinþe: ♦ formularea clarã a enunþului, fãrã ambiguitãþi sau formulãri incomplete; dacã se solicitã aprecierea cu ADEVÃRAT/FALS, se vor evita enunþurile foarte generale;

120

Introducere în .Net Framework (Suport de curs)

♦ selectarea unor enunþuri relevante pentru domeniul de cunoaºtere sau categoria de competenþe testatã (uneori, efortul de a realiza enunþuri fãrã echivoc duce la elaborarea de itemi nesemnificativi din punct de vedere educaþional sau ºtiinþific); ♦ se va evita utilizarea unor enunþuri negative, acestea conducând la raþionamente ce folosesc dubla negaþie, inducând un grad înalt de ambiguitate; ♦ se vor evita enunþurile lungi ºi complexe, prin eliminarea elementelor redundante inutile în raport cu ideea enunþului ºi cerinþa itemului; nu se va folosi un limbaj academic, o terminologie foarte specializatã sau o construcþie lingvisticã stufoasã ºi greoaie; ♦ se va evita introducerea a douã idei într-un singur enunþ, cu excepþia cazului în care se doreºte evidenþierea relaþiei dintre acestea; ♦ enunþurile vor fi aproximativ egale ca lungime; ♦ enunþurile adevãrate sau false sã fie aproximativ egale ca numãr, dar nu exact egale, deoarece acesta ar putea constitui un indiciu dupã care elevul încearcã sã ghiceascã rãspunsul corect. a.2. Itemi de tip pereche Itemii de tip pereche solicitã stabilirea unor corespondenþe între informaþiile distribuite pe douã coloane. Prima coloanã conþine informaþii de tip enunþ (premise), cea de-a doua coloanã conþinând informaþii de tip rãspuns. Elevului i se solicitã sã asocieze fiecare enunþ cu un unic rãspuns. Cele douã coloane sunt precedate de instrucþiuni de asociere în care i se explicã elevului tehnica de formare a perechilor (sã uneascã printr-o linie, sã rescrie perechile asociate sau doar elementele lor de identificare etc.) ºi se precizeazã dacã un rãspuns poate fi folosit la mai mult de un enunþ (dacã funcþia de asociere este injectivã sau nu), eventual dacã existã rãspunsuri care nu vor fi folosite niciodatã (dacã funcþia de asociere este surjectivã sau nu). Se verificã prin intermediul itemilor de tip pereche capacitatea elevului de a stabili corelaþii între: − funcþii ºi instrumente; − simboluri ºi concepte; − termeni ºi definiþii; − probleme ºi metode de rezolvare. Itemii de acest tip permit abordarea unui volum mare de informaþie într-un interval de timp relativ redus. Factorul de discriminare este ceva mai mare decât în cazul itemilor cu alegere dualã, strategia de asociere “la întâmplare” neconducând decât în situaþii foarte rare la un rezultat acceptabil privind rezultatul testului. Pentru proiectarea corectã a itemilor de tip de pereche este necesarã respectarea urmãtoarelor cerinþe: ♦ utilizarea unui material omogen, dintr-o sferã relativ restrânsã; ♦ utilizarea unui numãr inegal de premise ºi rãspunsuri, astfel încât, dacã elevul asociazã corect n-1 enunþuri dintre cele n date, sã nu rezulte automat rãspunsul pentru cel de-al n-lea enunþ;

CAPITOLUL 7. MiniGhid Metodologic

121

♦ aranjarea listei de rãspunsuri (mai ales dacã sunt multe) într-o ordine logicã, astfel încât cãutarea rãspunsului în listã sã se realizeze cât mai comod; ♦ aranjarea enunþurilor în listã astfel încât sã nu se poatã intui o regulã de asociere (referinþele sã fie “încruciºate”); ♦ aranjarea coloanelor astfel încât acestea sã încapã în întregime pe aceeaºi paginã. a.3. Itemi cu alegere multiplã Itemii cu alegere multiplã sunt cele mai utilizate tipuri de itemi, în special în testele standardizate (bacalaureat, admitere etc.) Un item cu alegere multiplã este format dintr-un enunþ numit premisã sau bazã ºi un numãr de opþiuni din care elevul trebuie sã aleagã un singur rãspuns numit cheie. Celelalte rãspunsuri, neconforme cu cerinþa, dar plauzibile poartã numele de distractori. Se verificã prin intermediul itemilor de tip pereche capacitatea elevului de a identifica: − definiþii ºi notaþii; − instrumentul adecvat unei prelucrãri; − secvenþe de program care realizeazã o anumitã prelucrare; − expresii cu o valoare datã; − termeni ºi expresii de specialitate; − metode de rezolvare ºi tehnici de implementare. Itemii de acest tip permit abordarea unui volum mare de informaþie într-un interval de timp relativ redus, oferind posibilitatea evaluãrii unor achiziþii cognitive complexe, deºi nu pot mãsura capacitatea elevului de a-ºi organiza ºi exprima ideile. Sunt forme de testare cu un grad mare de fidelitate, iar factorul de discriminare este mai mare decât în cazul celorlalþi itemi obiectivi. Abilitatea profesorului de a elabora distractori cât mai plauzibili, care sã construiascã toate alternativele posibile de a greºi, contribuie la reuºita aplicãrii testelor cu alegere multiplã. Erorile comise de elevi oferã profesorului informaþii suplimentare necesare în autoreglarea procesului de învãþãmânt. O categorie de itemi cu alegere multiplã solicitã rãspunsul corect, celelalte variante fiind greºite, în timp ce alþi itemi solicitã cel mai bun rãspuns, pe baza unei discriminãri complexe. În aceste cazuri trebuie manifestatã grijã la formularea cerinþei astfel încât criteriul de discriminare a “celui mai bun rãspuns” sã reiasã clar din enunþ. Pentru proiectarea corectã a itemilor cu alegere multiplã este necesarã respectarea urmãtoarelor cerinþe: ♦ stabilirea clarã a cerinþei, în concordanþã cu obiectivul de evaluare; ♦ furnizarea tuturor informaþiilor necesare în premisã, eliminându-se materialul irelevant; ♦ formularea premisei folosind afirmaþii sau întrebãri pozitive; ♦ construirea unor alternative plauzibile, aflate în concordanþã cu premisa; ♦ construirea itemului astfel încât sã existe o singurã alternativã “corectã” sau “cea mai bunã”; ♦ construirea unor alternative astfel încât distractorii sã fie în mod cert “greºiþi” sau “mai puþin buni”, iar varianta cheie sã fie în mod cert “corectã” sau “cea mai bunã”;

122

Introducere în .Net Framework (Suport de curs)

♦ aranjarea listei de rãspunsuri într-o ordine logicã, astfel încât cãutarea rãspunsului în listã sã se realizeze cât mai comod; ♦ construirea ansamblurilor de itemi cu alegere multiplã astfel încât rãspunsurile sã ocupe poziþii diferite în lista de variante (sã nu fie în mod constant al doilea rãspuns, de exemplu) b. Itemi semiobiectivi Itemii semiobiectivi formeazã o categorie de instrumente de evaluare ce solicitã construirea parþialã sau totalã a unui rãspuns pe baza unei sarcini definite. Itemii semiobiectivi sunt caracterizaþi prin: ♦ posibilitatea de a testa o gamã mai largã de capacitãþi intelectuale ºi rezultate ale învãþãrii; ♦ crearea unor situaþii cognitive de nivel mai ridicat prin solicitarea de elaborare a rãspunsului ºi nu de alegere a lui dintr-o mulþime prestabilitã, ca în cazul itemilor obiectivi; ♦ raportarea parþial subiectivã a profesorului în raport cu rãspunsul formulat (rãspunsul poate fi scris ordonat sau dezordonat, formularea poate fi mai clarã sau mai neclarã, termenii folosiþi se pot încadra în niºte standarde ºtiinþifice sau pot fi variante particulare ale acestora etc.) ♦ posibilitatea asocierii unui sistem de notare în care pot sã intervinã situaþii neprevãzute (rãspunsuri neaºteptate, care comportã raportãri noi la barem). b.1. Itemi cu rãspuns scurt / de completare Itemii cu rãspuns scurt solicitã ca elevul sã formuleze un rãspuns scurt sau sã completeze o afirmaþie astfel încât aceasta sã capete sens sau sã aibã valoare de adevãr. Se pot verifica prin intermediul itemilor cu rãspuns scurt ºi de completare: − cunoaºterea unor noþiuni, expresii de specialitate, simboluri, notaþii etc.; − recunoaºterea ºi nominalizarea unor elemente vizuale specifice unui anumit mediu de lucru; − capacitatea de integrare a unor elemente necesare din punct de vedere sintactic sau semantic într-un context dat; − schimbarea unor elemente dintr-un context dat astfel încât sã se realizeze o finalitate precizatã. Itemii cu rãspuns scurt se prezintã cel mai des sub forma unor întrebãri. Ei solicitã un rãspuns sub o formã restrânsã (un numãr, un simbol, un cuvânt, o expresie, o propoziþie sau frazã concisã). Itemii de completarea se prezintã sub forma unui enunþ, unei afirmaþii incomplete. Ei solicitã gãsirea cuvîntului sau sintagmei care completeazã ºi dã sens enunþului respectiv. Pentru proiectarea corectã a itemilor cu rãspuns scurt / de completare este necesarã respectarea urmãtoarelor cerinþe: ♦ formularea enunþului astfel încât sã admitã un rãspus scurt, exprimat cu precizie;

CAPITOLUL 7. MiniGhid Metodologic

123

♦ formularea enunþului astfel încât acesta sã admitã un singur rãspuns corect, pe cât posibil; ♦ rezervarea unor spaþii pentru rãspuns care sã sugereze numãrul de cuvinte aºteptate (dacã acest lucru nu reprezintã un indiciu), nu ºi dimensiunea lor; ♦ vizarea unui rãspuns care sã reprezinte o sintezã de cunoºtinþe sau un rezultat al înþelegerii unei situaþii ºi mai puþin o reproducere a unor informaþii.

b.2. Întrebãri structurate
Întrebãrile structurate solicitã, printr-un sistem de subîntrebãri relative la o temã comunã, rãspunsuri de tip obiectiv, rãspunsuri scurte sau de completare prin care se pot evalua cunoºtinþele complexe referitoare la tema respectivã fãrã a solicita elaborarea unui rãspuns deschis (eseu). Se pot verifica prin intermediul întrebãrilor structurate: − capacitatea de a urmãri, recunoaºte, adapta ºi construi un algoritm pe o temã datã sau un program într-un limbaj de programare; − capacitatea de a realiza din aproape în aproape o prelucrare complexã utilizând un mediu de lucru informatic. O întrebare structuratã poate sã conþinã materiale suport ºi informaþii suplimentare ce se adaugã treptat, conferind procesului de evaluare varietate, complexitate ºi gradualitate. Se pot verifica totodatã cunoºtinþe, dar ºi priceperi ºi deprinderi sporind gradul de obiectivitate în raport cu itemii cu rãspuns deschis. Subîntrebãrile ce formeazã itemul permit creºterea progresivã a dificultãþii cerinþelor, dar este recomandat ca subîntrebãrile sã fie independente, adicã rãspunsul la o întrebare sã nu depindã de rãspunsul la întrebãrile precedente. Proiectarea lor necesitã atenþie, pricepere ºi timp. Pentru proiectarea corectã a întrebãrilor strucutrate este necesarã respectarea urmãtoarelor cerinþe: ♦ redactarea subîntrebãrilor astfel încât acestea sã solicite rãspunsuri simple la început crescând pe parcurs dificultatea acestora; ♦ formularea unor subîntrebãri autoconþinute (al cãror rãspuns corect sã nu depindã de rãspunsul corect la una dintre întrebãrile precedente;realizarea concordanþei dintre enunþul general (tema întrebãrii) ºi subîntrebãrile formulate. c. Itemi subiectivi (cu rãspuns deschis) Itemii subiectivi formeazã o categorie de instrumente de evaluare ce vizeazã creativitatea elevului, originalitatea ºi caracterul personal al rãspunsului. Deºi sunt uºor de formulat, itemii subiectivi ridicã probleme privind obiectivitatea evaluãrii. Itemii subiectivi sunt caracterizaþi prin: ♦ abordare globalã a unei sarcini asociate unui obiectiv ce nu poate fi evaluat prin intermediul itemilor obiectivi; ♦ crearea unor situaþii cognitive de nivel foarte ridicat prin solicitarea de a realiza interacþiuni reale ºi complexe între cunoºtinþe, abilitãþi ºi deprinderi;

124

Introducere în .Net Framework (Suport de curs)

♦ raportarea subiectivã a profesorului în raport cu rãspunsul formulat; ♦ necesitatea predefinirii unor criterii privind baremul de corectare ºi notare, criterii clare, judicioase ºi puternic anticipative; ♦ posibilitatea, în cazul în care baremul nu a prevãzut toate situaþiile de interpretare ºi construire a rãspunsului, a unor elemente noi (rãspunsuri neaºteptate) care comportã reanalizarea baremului. În cazul informaticii ºi tehnologiei informaþiei se pot elabora itemi subiectivi de tip eseu (structurat sau liber) ºi itemi de tip problemã (care necesitã proiectare, redactare ºi uneori implementare a rezolvãrii).

c.1. Itemi de tip eseu
Itemii de tip eseu pot fi structuraþi sau liberi. Itemii structuraþi sunt construiþi astfel încât rãspunsul aºteptat sã fie “orientat” cu ajutorul unor elemente din enunþ (indicii privind ordinea de tratare, numãrul de linii, formularea rãspunsului, ideile care trebuie sã fie atinse etc.). Un eseu liber nu furnizeazã în enunþ nici un fel de indicaþii sau constrângeri, elevul având libertatea sã-ºi strucutreze cum considerã ºi cum poate materialul pe care-l solicitã enunþul. Acest tip de eseu comportã operaþii de maximã complexitate (analizã, sintezã, sistematizare ºi restructurare) lãsând frâu liber fanteziei ºi capacitãþilor creative ale elevului. Deoarece la informaticã elementele de creativitate se manifestã mai ales prin rezolvãri de probleme ºi proiecte, iar în cazul tehnologiei informaþiei prin teme practice ºi proiecte, itemii de tip eseu preferaþi sunt cei structuraþi, un eseu liber nefiind necesar decât rar, pentru anumite teme cu un volum mai mare de elemente “informative” în raport cu achiziþiile “operaþionale”. Se pot verifica prin intermediul itemilor de tip eseu: − cunoºtinþele globale legate de stuctura sistemelor de calcul, sisteme de operare, evoluþia istoricã a sitemelor hard ºi soft, principiile de utilizare a unei anumite aplicaþii, etapele conceptuale ale proiectãrii unei aplicaþii etc. − capacitãþile de sistematizare a unor elemente prin construirea unor scheme sau reprezentãri grafice. Itemii de tip eseu se prezintã sub forma unor cerinþe generale însoþite eventual (pentru eseurile structurate) de indicii privind tratarea cerinþei. Se pot adãuga restricþii privind întinderea în timp sau spaþiu (numãr rânduri, pagini, paragrafe etc.) sau privind forma de prezentare a rãspunsului. c.2. Itemi de tip problemã Rezolvarea unei probleme presupune soluþionarea unei situaþii conflictuale generatã de neconcordanþe ivite între sistemul de achiziþii ºi situaþiile concrete descrise de un enunþ. Aceste neconcordanþe sunt generate uneori de nepotrivirea între contextul general al cunoºtinþelor ºi situaþiile particulare în care acestea trebuie sã fie aplicate. Alteori achiziþiile sunt dobândite prin experimente (situaþii particulare) ºi, pentru a fi aplicate în cu totul alte situaþii, acestea trebuie sã fie ridicate la un înalt nivel de abstractizare ºi generalizare.

CAPITOLUL 7. MiniGhid Metodologic

125

Rezolvarea de probleme este o activitate specificã ºi des utilizatã la disciplina “Informaticã”, elementele gândirii algoritmice, metodele de rezolvare ºi tehnicile de implementare fiind supuse unui “tir” sistematic de probleme prin care acestea sã formeze competenþe reale de programare. Capacitãþile cognitive superioare legate de aplicare creativã, gândire divergentã, descoperirea condiþiilor interne, alegerea modelului adecvat etc. sunt verificate prin itemi de acest tip. Obiectivele urmãrite prin utilizarea rezolvãrii de probleme sunt:
− obþinerea informaþiilor necesare rezolvãrii problemei; − formularea ºi testarea ipotezelor; − descrierea metodei de rezolvare a problemei; − elaborarea unui raport despre rezultatele obþinute; − posibilitatea de generalizare ºi transfer a tehnicilor de rezolvare.

Cerinþe suplimentare asociate unei probleme pot pune în evidenþã capacitatea elevului de a estima eficienþa unei rezolvãri, de a construi un algoritm conform unor criterii (limita de memorie, numãr de instrucþiuni etc.). Se pot formula probleme în care se furnizeazã algoritmul ºi se cere un enunþ de problemã care se rezolvã prin intermediul algoritmului respectiv. Acest tip de item impune o analizã atentã a algoritmului ºi asocierea lui cu una dintre problemele sau prelucrãrile numerice întâlnite la matematicã, fizicã sau în alte domenii, o formulare a enunþului care sã se caracterizeze prin coerenþã. Enunþurile pot fi formulate abstract, “la obiect” sau pot crea un “context” care trebuie modelat pentru a se ajunge la rezolvarea propriu-zisã. “Povestea” în spatele cãreia se ascunde problema are de cele mai multe ori conotaþii practice, descriind situaþii concrete de prelucrare, amintind cã rolul programatorului este acela de a “ordona” iniþial informaþia ºi operaþiile specifice unui anumit context ºi abia dupã aceea de a elabora algoritmul, de a implementa ºi verifica programul corespunzãtor. Aspecte de aceeaºi naturã se întâlnesc ºi în domeniul utilizãrii calculatorului, la Tehnologia informaþiei, când beneficiarul formuleazã un enunþ ºi utilizatorul trebuie sã-ºi aleagã programul de aplicaþie adecvat, din cadrul programului sã-ºi aleagã obiectele ºi instrumentele potrivite, sã proiecteze, pe paºi, prelucrarea astfel încât “produsul” (documentul, prezentarea, raportul etc.) sã rãspundã cerinþelor ºi sã fie realizat în timp record. Aspectele reale de concepþie, de creativitate ºi gândire divergentã intervin la realizarea machetelor, a prezentãrilor etc. Evaluarea prin rezolvare de probleme la informaticã ridicã uneori probleme din punctul de vedere al întocmirii baremului de corectare. Unele tendinþe exagerate tind sã impunã o corectare pe principiul: problemã=program funcþional corect (pornind de la premisa cã “un program care aproape merge e ca un avion care aproape zboarã”). Se recomandã totuºi ca baremul de corectare sã cuprindã fracþiuni din punctaj pentru diferitele aspecte pe care le comportã rezolvarea unei probleme la informaticã: corectitudinea sintacticã, structurarea datelor ºi declararea variabilelor, structurarea programului, corectitudinea algoritmului, eficienþa algoritmului, tratarea unor situaþii limitã, eventual explicarea metodei aplicate (chiar daca a fost aplicatã greºit) etc.

126

Introducere în .Net Framework (Suport de curs)

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

III.4.2. Metode complementare de evaluare
Metodele complementare de evaluare reprezintã instrumente suplimentare, nestandardizate, de evaluare dispunând de forme specifice cum ar fi: investigaþia, referatul, portofoliul, proiectul, observarea sistematicã a activitãþii elevului ºi autoevaluarea. Metodele complementare realizeazã actul evaluãrii în strînsã legãturã cu procesul educativ, prin întrepãtrundere cu etapele acestuia, urmãrind în special capacitãþile cognitive superioare, motivaþiile ºi atitudinea elevului în demersul educaþional. Metodele alternative de evaluare se caracterizeazã prin urmãtoarele: ♦ capacitatea de a transforma relaþia profesor-elev inducând un climat de colaborare ºi parteneriat; ♦ posibilitatea transformãrii procesului de evaluare prin înlocuirea tendinþei de a corecta ºi sancþiona prin aceea de a soluþiona erorile semnalate; ♦ posibilitatea de a deprinde elevul cu mecanismele de aurocorectare ºi autoeducare necesare ºi în procesul de integrare socialã; ♦ utilizarea mai amplã a tehnicilor ºi mijloacelor didactice; ♦ caracterul sumativ, realizat prin evaluarea cunoºtinþelor, capacitãþilor ºi atitudinilor pe o periadã mai lungã de timp ºi dintr-o arie mai largã; ♦ caracterul formativ, realizat prin valorificarea atitudinii elevului în raport cu propria sa evaluare; ♦ capacitatea de a realiza o evaluare individualizatã (observare sistematicã); ♦ capacitatea de a educa spiritul de echipã prin activitãþi de grup (investigaþii, proiecte); ♦ caracterul profund integrator realizat prin interdisciplinaritate, educare ºi instruire mutilateralã. 1. Investigaþia Investigaþia este o metodã de evaluare ºi învãþare utilizatã foarte des la disciplina Tehnologie informaþiei ºi numai ocazional la disciplina Informaticã.

CAPITOLUL 7. MiniGhid Metodologic

127

Organizarea unei activitãþi de evaluare ºi învãþare prin metoda investigaþiei presupune: − valorificarea metodei de învãþare prin descoperire; − studiul unor documentaþii complementare, experimentarea unor instrumente de prelucrare nestandard, compararea ºi generalizarea unor tehnici ºi metode utilizate în tehnologie prin cercetarea altor izvoare sau prin utilizarea altor instrumente echivalente; − extrapolarea cunoºtinþelor dobândite ºi verificarea ipotezelor formulate; − solicitarea unor cunoºtinþe sau deprinderi dobândite la alte dicipline prin adaptarea creatoare a acestora la cerinþele temei de investigaþie. În cele mai multe dintre cazuri investigaþia trebuie sã fie organizatã ca muncã independentã depusã de elev, dirijatã ºi sprijinitã de profesor. Tehnologia informaþiei, cu multitudinea de aplicaþii software din domenii atât de variate, este un teren ideal pentru desfãºurarea investigaþiilor. Elevul cerceteazã “posibilitãþile” unei aplicaþii (de exemplu, aplicaþia româneascã de tip agendã MyCount difuzatã pe Internet): citeºte explicaþiile asociate butoanelor, opþiunile din meniuri, informaþiile din Help, experimenteazã operaþiile propuse de aplicaþie imaginând utilitatea practicã a acestora ºi formuleazã concluzii generale referitoare la acel soft (utilitate, spaþiul ocupat pe disc sau în memorie, spaþiul ocupat de produsele construite cu ajutorul lui, calitatea graficã ºi funcþionalã a interfeþei). Investigaþii mai rafinate pot realiza elevii iniþiaþi în programare ºi în sisteme de operare care disting mult mai multe aspecte “în spatele“ produsului soft investigat (eficienþã, posibilitate de dezvoltare, configurare, conflicte cu alte programe etc.). Pentru organizarea activitãþilor de investigaþie, profesorul va urmãri: ♦ formularea generalã a temei; ♦ asigurarea surselor bibliografice sau tehnice necesare; ♦ formularea unor indicaþii care sã direcþioneze activitatea elevilor; ♦ urmãrirea activitãþii elevului în sensul utilizãrii eficiente ºi creatoare a materialului de investigat; ♦ sprijinirea elevilor sau grupurilor de elevi care întâmpinã dificultãþi în înþelegerea temei sau a metodelor specifice de studiu; ♦ încurajarea ºi evidenþierea activitãþilor creatoare desfãºurate de elevi, a descoperirilor neaºteptate. 2. Referatul ºi proiectul Referatul reprezintã o formã de îmbinare a studiului individual cu activitate de prezentare ºi argumentare. Tema referatului, însoþitã de bibliografie ºi alte surse de documentare (Internet, vizite etc.), este tratatã în mod independent de cãtre elev ºi susþinutã apoi în faþa colegilor sau altui auditoriu mai larg. Varietatea universului informatic (a limbajelor ºi tehnicilor de programare, a aplicaþiilor din domeniul TIC, a noutãþilor hardware etc.) justificã utilizarea acestei forme de studiu ºi evaluare la clasã, atât la Tehnologia informaþiei cât ºi la Informaticã. Dacã studiul aferent ºi rezultatul studiului prezintã interes ºi din punct de vedre practic, rezultatul fiind un program (o aplicaþie) sau un produs TI complex (rezultatul aplicãrii creatoare a instru-

128

Introducere în .Net Framework (Suport de curs)

mentelor informatice), dacã bibliografia propusã este mai bogatã ºi etapele de proiectare (concepþie), implementare ºi testare necesitã un timp mai îndelungat, lucrarea poartã numele de proiect. Organizarea unei activitãþi de evaluare ºi învãþare prin intermediul referatelor ºi proiectelor presupune: − valorificarea metodei de învãþare prin descoperire; − studiul unor materiale suplimentare ºi izvoare de informare diverse în scopul îmbogãþirii ºi activizãrii cunoºtinþelor din domeniul studiat sau domenii conexe, prin completãri de conþinut ale programei sau prin aducerea în atenþie a unei problematici complet noi; − structurarea informaþiei corespunzãtoare unui referat într-un material ce poate fi scris, ilustrat sau prezentat pe calculator; activitãþile de concepere, organizare, experimentare, reproiectare (dacã este cazul), dezvoltare ºi elaborare a documentaþiei aferente necesitã planificarea unor etape de elaborare ºi o strategie de lucru, în cazul proiectului; − prezentarea referatului sau proiectului de cãtre elevul sau elevii care l-au elaborat, acesta (sau un reprezentant al grupului) trebuind sã-l susþinã, sã fie capabil sã dea explicaþii suplimentare, sã rãspundã la întrebãri etc. Referatul este de regulã o lucrarea de mai micã amploare, dar mai structuratã ºi mai bogatã în informaþii decât o temã de muncã independentã aferentã lecþiei curente. Proiectul este o lucrare mai amplã a cãrei temã este comunicatã sau aleasã din timp, elaborarea unui proiect putând sã dureze de la 1-2 sãptãmîni pânã la 2-3 luni sau chiar un semestru. Proiectul poate fi elaborat în grup, cu o distribuire judicioasã a sarcinilor între membrii grupului. Referatul poate fi utilizat la Informaticã ºi în egalã mãsurã la Tehnologia informaþiei temele referatelor vizând cel mai des domenii de actualitate în producþia sofware sau în domeniul TIC. Pentru a realiza o evaluare pe bazã de referate, profesorul: ♦ va formula teme clare, de complexitate medie, precizînd pe cât posibil amploarea lucrãrii (câte pagini, durata maximã necesarã prezentãrii etc.) ♦ va recomanda sau asigura sursele bibliografice ºi de informare necesare; ♦ îºi va rezerva suficient timp (în perioada de evaluare sau la sfârºitul unor unitãþi de învãþare) pentru ca elevii însãrcinaþi cu elaborarea referatelor sã-ºi poatã prezenta referatul; ♦ va supraveghea discuþiile purtate cu elevii asupra conþinutului referatului. Pentru a realiza o evaluare pe bazã de proiecte, profesorul: ♦ va formula teme practice, de complexitate sporitã, lãsând celor care elaboreazã proiectul multã libertate în a improviza, adapta ºi interpreta cerinþa într-un mod personal; ♦ va stabili un termen final ºi, în funcþie de modul de evaluare, termene intermediare de raportare;

CAPITOLUL 7. MiniGhid Metodologic

129

♦ va recomanda sau asigura sursele bibliografice ºi de informare necesare; ♦ îºi va rezerva suficient timp (în perioada de evaluare sau la sfîrºitul unor unitãþi de învãþare) pentru ca elevii însãrcinaþi cu elaborarea proiectelor sã-ºi poatã prezenta rezultatul proiectãrii; ♦ va supraveghea discuþiile purtate cu elevii asupra proiectului. 3. Portofoliul Portofoliul reprezintã o metodã complexã de evaluare în care un rezultat al evaluãrii este elaborat pe baza aplicãrii unui ansamblu variat de probe ºi instrumente de evaluare. Prin multitudinea de forme ºi momente în care se desfãºoarã testarea elevului, rezultatul final “converge” cãtre valoarea realã a acestuia, sesizând elementele de progres sau regres, ilustrând preocuparea pentru lãmurirea neclaritãþilor, oferind o imagine de ansamblu asupra nivelului cunoºtinþelor, gradului de formare a abilitãþilor ºi gradului de raportare atitudinalã pe care acesta o are faþã de tema evaluatã. Portofoliul este realizat pe o periadã mai îndelungatã, de la un semestru, un an, pânã la un ciclu de învãþãmânt. Conþinutul unui portofoliu este reprezentat de rezultatele la: lucrãri scrise sau practice, teme pentru acasã, investigaþii, referate ºi proiecte, observarea sistematicã la clasã, autoevaluarea elevului, chestionare de atitudini etc. La Tehnologia informaþiei portofoliul se poate constitui dintr-o colecþie de lucrãri practice realizate pe calculator, fiecare vizând anumite aspecte de utilizare. Alegerea elementelor ce formeazã portofoliul este realizatã de cãtre profesor (astfel încât acestea sã ofere informaþii concludente privind pregãtirea, evoluþia, atitudinea elevului) sau chiar de cãtre elev (pe considerente de performanþã, preferinþe etc.) Structurarea evaluãrii sub forma de portofoliu se dovedeºte deosebit de utilã, atât pentru profesor, cât ºi pentru elev sau pãrinþii acestuia. Pentru a realiza o evaluare pe bazã de potofoliu, profesorul: ♦ va comunica elevilor intenþia de a realiza un portofoliu, adaptând instrumentele de evaluare ce constituie “centrul de greutate” ale portofoliului la specificul disciplinei; ♦ va alege componentele ce formeazã portofoliul, dând ºi elevului posibilitatea de a adãuga piese pe care le considerã relevante pentru activitatea sa; ♦ va evalua separat fiecare piesã a portofoliului în momentul realizãrii ei, dar va asigura ºi un sistem de criterii pe baza cãrora sã realizeze evaluarea globalã ºi finalã a portofoliului; ♦ va pune în evidenþã evoluþia elevului, particularitãþile de exprimare ºi de raportare a acestuia la aria vizatã; ♦ va integra rezultatul evaluãrii portofoliului în sistemul general de notare. 4. Observarea sistematicã a activitãþii ºi comportamentului elevilor Fiºa de observare a activitãþii ºi comportamentului elevului înregistreazã informaþii legate de particularitãþile personalitãþii elevului manifestate în procesul didac-

130

Introducere în .Net Framework (Suport de curs)

tic, de achiziþiile evaluate spontan (rãspunsuri sporadice, atitudini semnificative etc.), de progresul înregistrat de acesta. Profesorul construieºte aceastã fiºã în vederea individualizãrii procesului sumativ de evaluare, dar ºi a celui de învãþare. Pe baza fiºei de evaluare se poate realiza ºi orientarea ºcolarã ºi profesionalã a elevului. Informaþiile din fiºa personalã au caracter parþial secret, parte dintre ele fiind comunicate elevului ºi pãrinþilor acestuia. Un model orientativ de fiºã de observare conþine: ♦ Date generale despre elev (nume, prenume, vârstã, climat educativ, condiþii materiale, particularitãþi socio-comportamentale); ♦ Particularitãþi ale proceselor intelectuale (gîndire, limbaj, imaginaþie, memorie, atenþie, spirit de observaþie etc.); ♦ Aptitudini ºi interese manifestate; ♦ Particularitãþi afectiv-motivaþionale; ♦ Trãsãturi de temperament; ♦ Atitudini ºi relaþionare (cu sine însuºi, cu materia studiatã, cu colegii) ♦ Consideraþii privind evoluþia aptitudinilor, atitudinilor, intereselor ºi nivelului de integrare. Prin stabilirea copmpetenþelor generale ale disciplinei ºi achiziþiile cognitive ºi comportamentale vizate de aceasta, fiºa de observare poate sã conþinã ºi considerente legate de atingerea ºi formarea competenþelor specifice. Completarea fiºei se realizeazã în timp într-un ritm adecvat specificului activitãþilor de la disciplina, din anul ºi de la clasa respectivã, dar ºi în funcþie de implicarea ºi de ritmul individual al elevului.

IV. Proiectul unitãþii de învãþare - Proiectul de lecþie?
Faþã de proiectarea tradiþionalã centratã pe lecþie (ora de curs) - proiectarea unitãþii de învãþare are urmatoarele avantaje: • creeazã un mediu de învãþare coerent în care aºteptãrile elevilor devin clare pe termen mediu ºi lung; • implicã elevii în ,,proiecte de învatare personale” pe termen mediu si lung rezolvare de probleme complexe, luare de decizii complexe, cu accent pe explorare ºi reflecþie; • implicã profesorul într-un ,,proiect didactic” pe termen mediu ºi lung, cu accent pe ritmurile de învãþare proprii ale elevilor; • dã perspectiva lecþiilor, conferind acestora o structurã specificã, în funcþie de secvenþa unitãþii de învãþare în care se aflã. Proiectul de lecþie - conceput ca document separat - este recunoscut ca o formalitate consumatoare de timp ºi energie. Proiectul unei unitãþi de învãþare conþine suficiente elemente pentru a oferi o imagine asupra fiecãrei ore. Ca urmare, în tabelul care sintetizeaza proiectarea unitatii de învãþare se pot delimita prin linii orizontale (punctate) spaþiile corespunzatoare unei ore de curs. Astfel, pentru fiecare lecþie, proiectul unitãþii de învãþare oferã date referitoare la elementele de conþinut ºi com-

CAPITOLUL 7. MiniGhid Metodologic

131

petenþele vizate, la care se raporteazã anumite activitãþi de învãþare; totodatã, sunt indicate resurse materiale, forme de organizare a clasei etc., pentru fiecare activitate precum ºi instrumente de evaluare necesare la nivelul lecþiei (orei). In consecinþã, dacã proiectul unitãþii de învãþare este bine construit, nu mai este necesarã detalierea la nivelul proiectului de lecþie. Lecþia este înþeleasã ca o componentã operaþionalã (Cum?) pe termen scurt a unitãþii de învãþare. Dacã unitatea de învãþare oferã întelegerea procesului din perspectivã strategicã, lecþia oferã înþelegerea procesului din perspectiva operativã, tacticã. Proiectul unitãþii de învãþare trebuie sã ofere o derivare simplã a lecþiilor componente. Ca urmare, trecerea de la unitatea de învãþare - o entitate supraordonatã - la o lecþie componentã trebuie sã permitã o ,,replicare” în acelaºi timp functionalã (De ce?), structuralã (Cu ce?) ºi operaþionalã (Cum?) a unitaþii de învãþare, la o scarã temporalã mai micã ºi într-un mod subordonat. Acest mod de tratare orientatã cãtre scopuri precise caracterizeazã organizarea atât a unitãþii de învãþare cât ºi a lecþiei.

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

132

Introducere în .Net Framework (Suport de curs)

5 Opþionalul ca disciplinã care apare în trunchiul comun la alte specialãzãri dis-

pune de o programã deja elaboratã la nivel central, ca programã obligatorie în cadrul unei anumite specialãzãri. Structura programei de opþional este aproximativ aceeaºi cu cea a programelor de trunchi comun elaborate la nivel naþional. În plus apare un Argument care motiveazã cursul propus, nevoile elevilor, ale comunitãþii locale, formarea unor competenþe de transfer.

A. Argument B. Competenþe specifice 1. 2. 3. …. D. Valori ºi atitudini E. Sugestii metodologice C. Conþinuturi

Tabel sintetic care asociazã tipurilor de opþional caracteristici obligatorii ale programei ºi modalitatea de notare în catalog

Tip de opþional Opþionalul de aprofundare

Caracteristici ale programei

Notare în catalog Aceeaºi rubricã în catalog cu disciplina sursã Aceeaºi rubricã în catalog

• Aceleaºi competenþe • Noi conþinuturi • Noi competenþe specifice corelate cu • Noi conþinuturi corelate cu cele din
programa de trunchi comun cele din programa de trunchi comun

Opþionalul de extindere

• Noi competenþe specifice diferite de
Opþionalul ca disciplinã nouã

• Noi conþinuturi diferite de cele din programa de trunchi comun

cele din programa de trunchi comun

Rubricã nouã în catalog

Opþionalul integrat

• Noi competenþe specifice complexe • Noi conþinuturi interdisciplinare

Rubricã nouã în catalog

Modulele din programa de clasa a XII-a, specializarea matematicã – informaticã pot constitui bazã pentru proiectarea unui opþional ca disciplinã nouã, opþional integrat sau Opþional ca disciplinã care apare în trunchiul comun la alte specializãri, pentru alte specializãri din filiera teoreticã sau vocaþionalã.

CAPITOLUL 7. MiniGhid Metodologic

133

VI.1. Anexa 1
a) Planificare calendaristicã Liceul........................... Disciplina INFORMATICÃ Profesor: ........................................... Clasa a XII-a , 3 ore/sãpt

Planificare calendaristicã
Anul ºcolar 2007-2008

Nr. Crt.

Unitãþi de învãþare

Competenþe Conþinuturi specifice

Nr. Ore

Sãptãmâna Observaþii

• Limbajul • •

1

Limbajul C#

1.3, 1.4, 3.1, 3.2

C# (structura unui proiect, declarãri de date, citiri/scrieri folosind dispozitive strandard, instrucþiuni, structuri de control, structuri de date) Interfaþa Visual Studio .Net, C# (meniuri, bare de instrumente, etapele realizãrii unei aplicaþii consolã, tehnici de depanare ºi autodocumentare) Programare proceduralã (subprograme, tehnici de transfer al parametrilor)

12

S1-S3

• Principiile programãrii orientate pe obiecte • Clase (structura clasei: date, metode ºi pro2 Programare Orientatã pe Obiecte

• Obiecte
1.1, 1.2, 1.3, 1.4, 3.1

• • •

prietãþi, constructori, destructor) (instanþiere, specificatori de acces, membri statici ai unei clase) Derivare (moºtenire, definire ºi redefinire de metode, clase ºi metode abstracte, clase ºi metode sigilate, polimorfism) Ierarhii de clase predefinite (using) Aplicaþii consolã cu clase de bazã ale programãrii vizuale (clase predefinite, interfaþã, evenimente, excepþii) Ferestre (crearea ºi particularizarea formularelor) Controale Standard, Container ºi Components (proprietãþi, evenimente specifice, metode asociate evenimentelor, Sender) Obiecte de tip dialog ºi obiecte grafice Tratarea excepþiilor (ierarhia claselor de erori, try-catch-finally-throw) Construirea unei aplicaþii vizuale (proiect, spaþiu de nume, bare de instrumente, moduri de vizualizare ºi instrumente de depanare)

21

S4-S10

• Elemente • •
3 Programare vizualã 1.1, 2.1, 2,2, 3.1,3.2

21

S11-S17

• • •

• Structuri de date înlãnþuite (liste, stive, cozi,
4 Structuri de date în mediu vizual

• Baze de date (conexiuni, tabele, relaþii, con1.1, 1.2, 1.3, 1.4, 3.1, 3.2

clase generice; foreach)

• •

troale de tip DataSet, DataGridView, TableAdapter) Operaþii cu baze de date (comenzi SQL, generarea ºi executarea comenzilor) Construirea unei aplicaþii cu liste ºi tabele de viaþã al unui produs software (alegerea temei, definirea cerinþelor utilizator, modelarea soluþiei, implementarea ºi testarea produsului) Modele arhitecturale Realizarea ºi documentarea proiectului Prezentarea proiectului

18

S18-S23

• Ciclul
5 Dezvoltarea ºi 2.1, 2.2, 2.3, prezentarea 3.1, 3.2, 3.3 unei aplicaþii vizuale

• • •

30

S24-S33

134

s1

b) Proiectarea unitãþii de învãþare Liceul ................................. INFORMATICÃ Sãptãmânile S1-S3, Clasa a XII-a , 3 ore/sãptãmânã

Proiectul unitãþii de învãþare
An ºcolar 2007-2008 Unitatea 1. Limbajul C# (12 ore)
Nr. Conþinuturi Crt. Limbajul C# - structura unui proiect - declarãri de dat - citiri/scrieri folosind dispozitive strandard - instrucþiuni ºi structuri de control - structuri de date C.S. Activitãþi de învãþare Resurse Evaluare Observaþii

• Familiarizare/repetare • Program C# pentru o prelu2.1 2.2 1.4 sintaxã C crare simplã (simplificare fracþie, termeni Fibonacci din interval, cifra de control etc.) Realizare aplicaþie consolã corespunzãtoare Tipuri de date noi în C#. ªiruri de caractere Conversaþia, modelarea, exerciþiul Observare Act.frontalã sistematicã 3 ore se preferã algoritmi din tematica de atestat ºi bacalaureat

1

• •

• Discutarea structurii unui •
proiect simplu ºi enumerarea etapelor de realizare a acestuia Exersarea principalelor opþiuni din meniuri, butoane ºi shorcut-uri pentru realizarea unei aplicaþii consolã Program de prelucrare stringuri (inversare numeprenume, criptãri sau codificãri etc.) Aplicaþie consolã cu tablouri (ordonare, diagonale matrice etc.) Exerciþiul, demonstrarea Act. frontalã ºi individualã Fiºa de activ. Practicã 3 ore

2

Interfaþa Visual Studio .Net (C#) - meniuri ºi bare de instrumente 3.1 - etapele realizãrii unei aplicaþii consolã - tehnici de depanare ºi autodocumentare

• •

Observare sistematicã Investigaþie

• Definire funcþie (prim, palin3 Programare proceduralã - subprograme - tehnici de transfer al parametrilor 2.1 drom etc.) ºi subprogram procedural (transformare, citire, afiºare matrice, ordonare vector etc.) Aplicaþie consolã care apeleazã funcþia ºi procedura definite

Exerciþiul Act.frontalã ºi individualã Test evaluare 3 ore

Fiºa de evaluare 1.1

• Realizarea unei aplicaþii-joc
4 Realizarea unor aplicaþii consolã cu algoritmi elementari, structuri de date ºi subprograme 3.1 3.2

simple (centrate ºi necentrate, X ºi O, corãbii etc.) Discutarea algoritmilor de prelucrare, implementarea ºi testarea subprogramelor, implementarea aplicaþiei consolã

Conversaþia, exerciþiul Act.frontalã Fiºa de ºi evaluare individualã 1.2 3 ore

CAPITOLUL 7. MiniGhid Metodologic

135

c) Instrumente de evaluare FIªA DE EVALUARE 1.1 Nr.1 1. (1p.) Care dintre urmãtoarele variante reprezintã antetul corect al unui subprogram cif1 care primeºte o valoare realã prin intermediul parametrului r ºi returneazã prin intermediul parametrului z numãrul de cifre aflate la partea întreagã a lui r (de exemplu pentru r=5.12703, z va returna valoarea 1, iar pentru r=126, z va returna valoarea 3) a) static void cif1(ref float r,int z) b) static void cif1(float r, ref int z) c) int void cif1(float r) d) static float cif1(int z) 2. (1p.) Se ºtie cã sunt declarate o variabilã x ºi ea reþine o valoare realã oarecare ºi o variabila întreagã k ºi ea reþine valoarea 0. Care dintre urmãtoarele variante reprezintã un apel corect al subprogramului cif1 de la cerinþa 1? a) cif1(x,k) b) k=cif1(x,0) c) cif1(x,ref k) d) cif1(ref x, k) 3. (4p.) Scrieþi secvenþa de program ce realizeazã prelucrarea cerutã la 1. Valoarea variabilei reale x este consideratã cunoscutã, iar valoarea calculatã a lui z nu se va afiºa. 4. (3p.) Considerând implementat subprogramul cif1, scrieþi un program care citeºte de la tastaturã o valoare realã ºi, folosind apeluri ale subprogramului cif1, verificã dacã aceastã valoare are mai multe cifre la partea întreagã decât la cea zecimalã. Se va afiºa unul dintre mesajele DA sau NU.

136

ANEXA 1

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

CAPITOLUL 7. MiniGhid Metodologic

137

VI.2. Anexa 2
a) Planificare calendaristica Unitatea ºcolarã……………………………. Disciplina INFORMATICÃ Profesor……………………….. Clasa/Nr.Ore/sãpt 3 ore/sãpt

Planificarea calendaristicã
Anul ºcolar 2007-2008 MODUL Programare orientatã pe obiecte ºi programare vizualã (1 orã teorie + 2 ore activitaþi practice sau 3 ore activitãþi practice)
Nr. Unitãþi de crt. învãþare Competenþe specifice C1 Insuºirea conceptelor de abstractizare a datelor C2 Folosirea terminologiei specifice POO în contexte variate de aplicare C3 Organizarea datelor ce intervin în rezolvarea unei probleme utilizând structuri de date adecvate C4 Utilizarea facilitãþilor oferite de POO C5 Elaborarea ºi realizarea unei aplicaþii, folosind un mediu de programare specific Conþinuturi 1.1 Principiile programãrii orientate pe obiecte 1.2 Structura unei aplicaþii orientatã pe obiecte 1.3 Clase ºi obiecte 1.4 Derivarea claselor 1.5 Tratarea erorilor 1.6 Polimorfism Nr. Sãptãmânã Observatii ore 3 S1

12

S2-S5

33 6 3 3

S6-S16 S17-S18 S19 S20

1.

PROGRAMAREA ORIENTATÃ PE OBIECTE

1.7 Recapitulare

3

S21

2.

C6 Exprimarea ºi redactarea coerentã în limbaj formal sau în limbaj cotidian, a rezolvãrii sau a strategiilor de rezolvare a unei probleme C7 Analiza de situaþiiproblemã în scopul descoperirii de strategii pentru optimizarea soluþiilor C8 Generalizarea unor proprietãþi prin moPROGRAMAREA dificarea contextului VIZUALÃ iniþial de definire a problemei sau prin generalizarea algoritmilor C9 Întelegerea principiilor de proiectare a interfetelor C10) Utilizarea instrumentelor de dezvoltare a unei aplicaþii C11) Elaborarea ºi realizarea unei aplicaþii, folosind un mediu de programare specific C12) Prezentarea unei aplicaþii

2.1 Concepte de bazã ale programãrii vizuale

3

S22

2.2 Prezentarea unui mediu de programare vizual (Microsoft Visual C#, Delphi, Microsoft Visual Basic etc.).

3

S23

2.3 Elementele POO în context vizual

3

S24

2.4 Construirea interfeþei utilizator

15

S25-S29

2.5 Accesarea ºi prelucrarea datelor

12

S30-S33

2.6 Dezvoltarea ºi prezentarea unei aplicaþii în mediu vizual

6

S34-S35

138

ANEXA 2

b) Proiectul unitãþii de învãþare Unitatea ºcolarã………………………. Disciplina INFORMATICÃ Profesor………………………….....….. Sãptãmâna/ Anul………….………….. Clasa/Nr. Ore /sãpt……… 3ore/sãpt.

Proiectul unitatii de invatare
Unitatea de învãþare PROGRAMAREA ORIENTATÃ PE OBIECTE Nr. Ore alocate: 63
Nr. Conþinuturi Crt Resurse C.S. Activitãþi de învãþare
Temporale Forme de (ore) organizare - pentru a ilustra principiile programãrii orientatã pe obiecte ºi modul de structurare a unei aplicaþii POO se va prezenta ºi analiza o aplicaþie gata implementatã; se va realiza o analizã comparativã între abordarea POO în raport cu abordarea specificã programãrii structurate; Materiale

Evaluare Tip/ instrument

Observaþii

1.

Principiile programãrii orientate pe obiecte

C1

3

Frontalã

Iniþialã/ Studiu de caz Anexa 1 Jurnal Reflexiv Anexa 2

Structura unei aplicaþii orientatã pe obiecte

2.

2.1 Arhitectura platformei Microsoft .NET, componente ale lui .NET Framework, trãsãturi ale platformei .NET 2.2 Structura generalã a unei aplicaþii C# 2.3 Tipuri de date (predefinite,val oare, enumerare)

C1 C2 C4

2.4 Tablouri Tablouri unidimensionale, Tablouri multidimensionale 2.5 String-uri

C2 C4 C5

- analiza arhitecturii platformei .NET - formularea trãsãturilor platformei .NET - identificarea caracteristicilor fiecãrei componente ale platformei .NET - exerciþii de descriere a metodei de rezolvare a unei probleme din perspectiva structurãrii datelor; - exerciþii de utilizare a selecþiei, iteraþiei ºi saltului - exerciþii de identificare a tipurilor de date necesare în aplicaþii - formularea unor probleme simple; discuþii preliminare ºi analiza problemei; - formularea ºi rezolvarea unor probleme care necesitã utilizarea datelor structurate

3

Formativã/ Individualã R.A.I. Frontalã Anexa 3 Anexa 4 Pe grupe Anexa 5

6

Individualã Anexa 6 Formativã/ Frontalã Anexa 7 Exerciþiul Pe grupe

C2 C4 C5

3

Individualã Formativã/ Frontalã Anexa 8 Exerciþiul Pe grupe

CAPITOLUL 7. MiniGhid Metodologic

139

Resurse Nr. Conþinuturi Crt C.S. Activitãþi de învãþare
TempoForme de rale organizare (ore)

Evaluare Tip/ instrument Materiale

Observaþii

Clase ºi obiecte
3.1.Definirea claselor ºi a obiectelor 3.2.Utilizarea claselor ºi a obiectelor 3.3.Specificatori de acces la membrii unei clase 3.4.Funcþii. Transmiterea parametrilor 3.5.Crearea obiectelor; Constructori 3.6.Distrugerea obiectelor Destructori 3.7.Operatori 3.8.Delegaþi 3.9.Evenimente C2 C4 C2 C3 C4 C2 C5 C2 C5 C2 C4 C2 C4 C5 C2 C3 C3 C4 C2 C5 3
- pentru ca elevii sã înþeleagã diferenþele specifice abordãrii POO, se va alege una dintre aplicaþiile familiare elevilor (de exemplu: numere complexe, numere raþionale, polinoame, liste, etc.), care va fi analizatã din perspectiva POO, apoi se vor implementa clasele necesare ºi se va realiza o aplicaþie în care vor fi utilizate clasele create; exerciþii de utilizare a conversiilor -exerciþii care implicã boxing ºi unboxing -exerciþii de definire ºi apelare a metodelor -exerciþii de utilzare a delegãrilor

Frontalã

Anexa 9

Iniþialã/ Exerciþiul

3

6

Anexa Frontalã Anexa Individualã Anexa Frontalã Individualã Anexa Pe grupe

10 Formativã/ 11 Exerciþiul T 12 3-2-1 13 Formativã/ Exerciþii

3

3.

Frontalã Formativã/ Anexa 14 Individualã R.A.I. Frontalã Formativã Anexa 15 Individualã Exerciþiul Frontalã Formativã/ Individualã Anexa 16 Exerciþiul Pe grupe Frontalã Formativã Anexa 17 Individualã Exerciþiul Frontalã Formativã Anexa 18 Individualã Exerciþii Frontalã Formativã/ Anexa 19 Individualã Studiu de caz

3

3

3 3 6

Derivarea claselor
Definirea noþiunii de moºtenire simplã ºi moºtenire multiplã Declararea unei clase derivate Drepturi de acces în clase derivate Constructori ºi destructor în clase derivate C2 C3 C4 C5
- se va analiza un exemplu de ierarhie de clase gata implementatã, pentru a înþelege mecanismele care guverneazã derivarea claselor;

4

6

Formativã Frontalã T 3-2-1 Individualã Anexa 21 Studiu de Pe grupe caz Exerciþiul

Tratarea erorilor
5 Ce este o eroare Cum se genereazã Tratarea/propagarea erorilor Ierarhia claselor de erori C2 C3 C4 C5 C2 C3 C4 C5

- discuþii privind validitatea datelor; - testarea ºi analizarea comportamentului aplicaþiilor pentru diferite date de intrare;

3

Formativã/ Frontalã Anexa 22 Exerciþii Individualã R.A.I.

Polimorfism
6 Funcþii virtuale Clase abstracte ºi funcþii virtuale pure

3

Frontalã Formativã/ Anexa 23 Individualã T 3-2-1

7

Recapitulare

C1 C2 C3 C4 C5

- fiecare elev va alege o problemã concretã, va defini clasele/ierarhiile de clase necesare ºi va crea o aplicaþie în care sã fie utilizate clasele/ierarhiile de clase create; în acest scop se poate folosi un mediu vizual; elevii vor prezenta colegilor aplicaþiile create; profesorul va stimula discuþiile critice ºi creative pe marginea aplicaþiilor elaborate de elevi;

3

Frontalã Individualã Pe grupe

Sumativã/ Proiect

140

ANEXA 3

VI.3. Anexa 3
a) Planificare calendaristicã PROGRAMARE WEB Unitatea ºcolarã……………………………. Disciplina INFORMATICÃ Profesor……………………….. Clasa/Nr.Ore/sãpt 3 ore/sãpt

Planificarea calendaristicã
Anul ºcolar 2007-2008

Nr. Unitãþi de învãþare Crt. Principii generale ale proiectãrii interfeþelor Web

Competenþe specifice 1.1 Analizarea unei probleme în scopul identificãrii ºi clasificãrii resurselor necesare Analizarea unei probleme în scopul identificãrii ºi clasificãrii resurselor necesare

Conþinuturi
1. Etapele procesului de dezvoltare

Nr. Ore 2h

Sãpt. 1

a unei aplicaþii Web
2. Aspecte generale ale proiectãrii

1.1

interfeþelor Web
3. Realizare interfeþelor Web

2h

1-2

2.1 1.

Identificare tehnicilor de programare adecvate rezolvãrii unei probleme ºi aplicarea creativã a acestora 3.28 Utilizarea foilor de stil, a principiilor de bazã ale structurii unei foi de stil 3.29 Folosirea comenzilor asociate foilor de stil CSS, ale stilurilor CSS în paginile HTML

utilizând HTML

7h

2-4

4. Foi de stiluri (CSS)

6h

4-6

5. Evaluare sumativã

1h 1h 1h 13h 15h 3h 3h

6 7 7 7-11 12-16 17 18

3.1 3.1 2. Mediul de lucru 3.1

Utilizarea instrumentelor de dezvoltare a unei aplicaþii Utilizarea instrumentelor de dezvoltare a unei aplicaþii Utilizarea instrumentelor de dezvoltare a unei aplicaþii

1. Modelul client - server,

protocoale de comunicaþii
2. Server Web - IIS 4. Prezentarea limbajului de

scripting - ASP
5. Evaluare sumativã

3.24 Operarea cu baze de date 3.25 Utilizarea informaþiilor dintr-o bazã de date 3.26 Aplicarea operaþiilor elementare pe o bazã de date 3. Interaþiunea cu baze de date Web 3.1 Utilizarea instrumentelor de dezvoltare a unei aplicaþii 3.22 Elaborarea ºi realizarea unei aplicaþii folosind un mediu de programare specific 2.3 Analiza comparativã a eficienþei diferitelor tehnici de rezolvare a problemei respective ºi alegerea celei mai eficiente variante

1. Definirea ºi gestionarea unei

baze de date

2. Lucrul cu baze de date

18h

19-24

3. Proiectarea ºi realizarea unei

aplicaþii Web

33 h

25-35

TOTAL

105h

BIBLIOGRAFIE
• Marshall Donis, Programming Microsoft Visual C# 2005: The Language, Microsoft Press 2006,

ISBN:0735621810
• Pelland Patrice, Build a Program NOW, Microsoft Visual C# 2005 Express Edition, Microsoft Press

2006,
• LearnVisualStudio.NET http://www.learnvisualstudio.net resurse educaþionale gratuite sub forma de

filme
• Harris Andy, Microsoft C# Programming for the Absolute Beginner, Premier Press 2002,

ISBN: 1?931841?16?0
• Wright Peter, Beginning Visual C# 2005 Express Edition: From Novice to Professional, Apress 2006,

ISBN-13 (pbk): 978-1-59059-549-7, ISBN-10 (pbk): 1-59059-549-1
• Liberty Jesse, Programming C#, Second Edition, O'REILLY 2002, ISBN 10: 0-596-00309-9,

ISBN 13:9780596003098
• Solis Daniel, Illustrated C# 2005, Apress 2006, ISBN-13 (pbk): 978-1-59059-723-1,

ISBN-10 (pbk): 1-59059-723-0
• Rasheed Faraz, C# School, Synchron Data 2005-2006,

http://www.programmersheaven.com/2/CSharpBook
• Schneider Robert, Microsoft® SQL Server™ 2005 Express Edition For Dummies®, Wiley Publishing

2006, ISBN-13: 978-0-7645-9927-9, ISBN-10: 0-7645-9927-5
• Bradley L. Jones, Sams Teach Yourself the C# Language in 21 Days, SAMS, 2004,

International Standard Book Number: 0-672-32546-2
• Michel de Camplain, Brian G. Patrik, C# 2.0: Practical Guide for Programmers, Elsevier, 2005,

ISBN: 0-12-167451-7
• Christian Nagel, Bill Evjen, Jay Glynn, Karli Watson, Morgan Skinner, Allen Jones,

Professional C# 2005, Wiley Publishing, Inc., 2006, ISBN-13: 978-0-7645-7534-1 ISBN-10: 0-7645-7534-1 • Sharp John, Visual C# 2005, DUNOD 2006 • Iulian Serban, Dragos Brezoi, Tiberiu Radu, Adam Ward, GDI+ Custom Controls with Visual C# 2005, PACKT Publishing 2006, ISBN 1-904811-60-4 • Simpson Alan, Visual Web Developer Server™ 2005 Express Edition For Dummies®, Wiley Publishing 2006, ISBN-13: 978-0-7645-8360-5, ISBN-10: 0-7645-8360-3 • Hoffman Kevin, Microsoft® Visual C# 2005 Unleashed, Sams 2006, ISBN-10: 0-672-32776-7, ISBN-13: 978-0-672-32776-6 • Popovici, Dorin Mircea ºi colaboratorii - Proiectare ºi implementare software, Editura TEORA, Bucureºti, 1998 • C# Language Specification, Microsoft Corporation, 1999-2003 • C# Version 2.0 Specification May 2004, Microsoft Corporation, 1999-2005 • David Conger, Programarea în C#, editura B.I.C. ALL 2003 • Chris H. Pappas, William H. Murray C# pentru programarea Web, editura B.I.C. ALL 2004 • MCAD/MCSD -Developing XML WEB SERVICES and SERVER COMPONENTS WITH MICROSOFT http://www.csharp-station.com http://msdn2.microsoft.com • M.E.C. Serviciul Naþional de Evaluare ºi Examinare - Ghid de evaluare, INFORMATICA ºi TEHNOLOGIA INFORMATIEI, Editura Aramis, Bucureºti 2001 • M.E.C. Consiliul Naþional pentru Curriculum - Ghid metodologic pentru aplicarea programelor ºcolare, Editura Aramis, Bucureºti 2002 • M.E.C Consiliul Naþional pentru curriculum - Ghid metodologic pentru Educaþie Tehnologicã Informaticã - Tehnologia Informaþiei - Liceu teoretic - Editura Aramis, Bucureºti 2001

Autori, în ordine alfabetică: Adrian Niţă

Suport de curs pentru profesori

.Net Framework
ISBN: 973-86699-6-0

Introducere în

Ediţia 2008

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->