Cap 1 Manual C#

User Manual:

Open the PDF directly: View PDF .
Page Count: 124 [warning: Documents this large are best viewed by clicking the View PDF Link!]

Grup elaborare suport curs:

Nuºa Dumitriu-Lupan, Inspector General M.E.C.T.

Rodica Pintea, profesor, Liceul Grigore Moisil, Bucureºti

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

Mioara Niþã, profesor, Colegiul Naþional Emanuil Gojdu, Oradea

Cristina Sichim, profesor, Colegiul Naþional Ferdinand I, Bacãu

Nicolae Olãroiu, profesor Colegiul Naþional "B.P. Haºdeu", Buzãu

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

Petru Jucovschi, Developer Community Lead, Microsoft România

Tudor-Ioan Salomie,Team Lead Microsoft Student Partners,

Universitatea Tehnicã Cluj Napoca

Autori

M.E.C.T.:

MICROSOFT:

Introducere

în Programarea

.Net Framework

Ministerului Educaþie,

Cercetãrii ºi Tineretului

Programarea

Orientatã pe Obiecte

ºi

Programarea Vizualã

cu C# .Net

CUPRINS

CUPRINS.................................................................................................................................................... 1

1. PROGRAMAREA ORIENTATĂ OBIECT (POO) ..................................................................... 3

1.1. EVOLUŢIA TEHNICILOR DE PROGRAMARE.................................................................................. 3

1.2. TIPURI DE DATE OBIECTUALE. ÎNCAPSULARE ............................................................................ 3

1.3. SUPRAÎNCĂRCARE ..................................................................................................................... 4

1.4. MOŞTENIRE ...............................................................................................................................5

1.5. POLIMORFISM. METODE VIRTUALE ........................................................................................... 5

1.6. PROGRAMARE ORIENTATĂ OBIECT ÎN C#................................................................................... 6

1.7. DECLARAREA UNEI CLASE......................................................................................................... 6

1.8. CONSTRUCTORI ......................................................................................................................... 7

1.9. DESTRUCTOR............................................................................................................................. 7

1.10. METODE .................................................................................................................................... 8

1.11. PROPRIETĂŢI ............................................................................................................................. 9

1.12. EVENIMENTE ŞI DELEGĂRI....................................................................................................... 10

1.13. INTERFEŢE...............................................................................................................................11

1.14. FIRE DE EXECUŢIE ................................................................................................................... 12

2. PLATFORMA .NET..................................................................................................................... 13

2.1. PREZENTARE ........................................................................................................................... 13

2.2. .NET FRAMEWORK ................................................................................................................. 13

2.3. COMPILAREA PROGRAMELOR .................................................................................................. 14

3. LIMBAJUL C#.............................................................................................................................. 14

3.1. CARACTERIZARE ..................................................................................................................... 14

3.2. COMPILAREA LA LINIA DE COMANDĂ ...................................................................................... 14

3.3. CREAREA APLICAŢIILOR CONSOLĂ .......................................................................................... 15

3.4. STRUCTURA UNUI PROGRAM C# .............................................................................................. 16

3.5. SINTAXA LIMBAJULUI.............................................................................................................. 16

3.6. TIPURI DE DATE ....................................................................................................................... 17

3.7. CONVERSII...............................................................................................................................21

3.8. CONSTANTE............................................................................................................................. 22

3.9. VARIABILE .............................................................................................................................. 22

3.10. EXPRESII ŞI OPERATORI ........................................................................................................... 22

3.11. COLECŢII ................................................................................................................................. 23

3.12. INSTRUCŢUNEA FOREACH ......................................................................................................... 23

3.13. INSTRUCŢIUNILE TRY-CATCH-FINALLY ŞI THROW ................................................................... 23

4. PROGRAMARE VIZUALĂ........................................................................................................ 25

4.1. CONCEPTE DE BAZĂ ALE PROGRAMĂRII VIZUALE .................................................................... 25

4.2. MEDIUL DE DEZVOLTARE VISUAL C#...................................................................................... 26

4.3. FERESTRE ................................................................................................................................ 27

4.4. CONTROALE ............................................................................................................................ 29

4.5. SYSTEM.DRAWING .................................................................................................................. 36

4.6. VALIDAREA INFORMAŢIILOR DE LA UTILIZATOR ..................................................................... 37

5. APLICAŢII ORIENTATE PE DATE......................................................................................... 38

5.1. STRUCTURI DE DATE................................................................................................................ 38

5.2. COLECŢII DE DATE................................................................................................................... 38

5.3. ADO.NET............................................................................................................................... 39

5.4. CONECTAREA LA O SURSĂ DE DATE......................................................................................... 39

5.5. EXECUTAREA UNEI COMENZI SQL .......................................................................................... 41

5.6. SETURI DE DATE ...................................................................................................................... 42

5.7. PROIECTAREA VIZUALĂ A SETURILOR DE DATE ....................................................................... 43

Programarea Orientată Obiect (POO) 3

1. Programarea Orientată Obiect (POO)

1.1. Evoluţia tehnicilor de programare

• Programarea nestructurată (un program simplu, ce utilizează numai variabile globale);

complicaţiile apar când prelucrarea devine mai amplă, iar 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 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.

program principal

date

modul_1

(date+date1)

• subprog_1

• subprog_2

• subprog_3

modul_2

(date+date2)

• subprog_1

• subprog_2

obiect1

• date1

•met1

obiect4

• date4

• me

obiect2

• date2

•me

obiect3

• date3

• me

4 POO şi Programare vizuală (suport de curs)

Un exemplu de-acum clasic de tip de date abstract este STIVA. Ea poate avea ca date:

numerele naturale din stivă, capacitatea stivei, 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 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 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încărcarea permite obţinerea

unor efecte diferite ale apelului în contexte diferite3.

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

3 Capacitatea unor limbaje (este şi cazul limbajului C#) de a folosi ca ”nume” al unui

subprogram un operator, reprezintă supraîncărcarea operatorilor. Aceasta este o facilitate care

Programarea Orientată Obiect (POO) 5

Apelul unei funcţii care beneficiază, prin supraîncărcare, de 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-ilea caracter.

1.4. Moştenire

Pentru tipurile de date obiectuale class este posibilă o operaţie de extindere sau

specializare a comportamentului unei clase existente prin 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 diferiţ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

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

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

6 POO şi Programare vizuală (suport de curs)

derivate din PIESA, referirea la metoda muta pare nedefinită. Totuşi mecanismele POO

permit stabilirea, în momentul apelului, a clasei proxime că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 decalră 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: new public protected

internal private (modificatori de acces) abstract sealed (modificatori de moştenire)

Clasa de bază este clasa de la care moşteneşte clasa curentă şi poate exista o singură

astfel de clasă de bază. Corpul clasei este un bloc de declarări ale membrilor clasei:

constante (valori asociate clasei), câmpuri (variabile), tipuri de date definite de utilizator,

metode (subprograme), constructori, un destructor, proprietăţi (caracteristici ce pot fi

consultate sau setate), evenimente (instrumente de semnalizare), indexatori (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)

8 echivalentrul claselor template din C++

9 [] din definiţia schematică semnifică un neterminal, iar o semnifică o componentă opţională

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

Copil

Fetita Baiat

Programarea Orientată Obiect (POO) 7

1.8. Constructori

Sintaxa:

[atrib]o [modificatori]o [nume_clasă] ([listă_param_formali]o) [:iniţializator]o [corp_constr]o

Modificatori: public protected internel private extern

Iniţializator: base([listă_param]o), this([listă_param]o) ce permite invocarea unui constructor

anume12 înainte de executarea instrucţiunilor ce formează corpul 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 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ă acceesibilă numai în interiorul clasei şi claselor derivate

public Copil() {nume = Console.ReadLine();}

public Copil(string s) {nume=s;}

}

class Fetita:Copil

{ public Fetita(string s):base(s) {nume=”Fetita ”+nume}13

public Fetita(){} //preia constructorul fără parametri din clasa de bază14

//public Fetita(string s):base() {nume=s}

}

...

Copil c1= new Copil(); //se citeste numele de la tastatură

Copil c2= new Copil(“Codrina”);

Fetita f1=new Fetita();Fetita f2=new Fetita("Ioana”);

Există două motive pentru care definiţia constructorului al 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

12 Din clasa de bază (base) sau din clasa insăşi (this)

13 Preia şi specializează constructorul al doilea din clasa de bază

14 Este echivalent cu public Fetita():base(){}

8 POO şi Programare vizuală (suport de curs)

nu pot fi moşteniţi. În mod normal, destructorul nu este apelat în mod explicit, deoarece

procesul de distrugere a unui obiect este invocat şi gestionat automat de Garbagge Collector.

1.10. Metode

Sintaxa:[atrib]o[modificatori]o[tip_returnat] [nume] ([listă_param_formali]o) [corp_metoda]o

Modificatori: new public protected internal private static virtual abstract

sealed override extern15

Tipul rezultat poate fi un tip definit sau void. Numele poate fi un simplu identificator sau, în

cazul în care defineşte în mod explicit un membru al unei 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 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

public class Copil

{ public const int nr_max = 5; //constantă

public static int nr_copii=0; //câmp simplu (variabilă)

static Copil[] copii=new Copil[nr_max]; //câmp de tip tablou (variabilă)

public static void adaug_copil(Copil c) //metodă

{ copii[nr_copii++] = c;

if (nr_copii==nr_max) throw new Exception("Prea multi copii");

}

public static void afisare() //metodă

{

Console.WriteLine("Sunt {0} copii:", nr_copii);

for (int i = 0; i<nr_copii; i++)

Console.WriteLine("Nr.{0}. {1}", i+1, copii[i].nume);

} ...17

}

...

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

referinţa noului obiect se memorează în tabloul static copii (caracteristic clasei) şi se

incrementează data statică nr_copii

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

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

Copil.afisare();//se afişează o listă cu numele celor 3 copii

15 Poate fi folosit cel mult unul dintre modificatorii static, virtual şI override ; nu pot apărea

împreună new şi override, abstract nu poate să apară cu niciunul dintre static, virtual, sealed, extern;

private nu poate să apară cu niciunul dintre virtual, override şi abstract; seald obligă şi la override

16 Din semnătură (amprentă) nu fac parte tipul returnat, numele parametrilor formali şi nici

specificatorii ref şi out.

17 Se are în vedere şi constructorul fără parametri definit şi preluat implicit în subclasele din cadrul

primului exemplu din subcapitolul 1.8: public Copil() {nume = Console.ReadLine();}

Programarea Orientată Obiect (POO) 9

 Definirea datelor şi metodelor nestatice corespunzătoare clasei Copil şi claselor derivate

public class Copil

{ ...

public string nume;

public virtual void se_joaca() //virtual  se poate suprascrie la derivare

{Console.WriteLine("{0} se joaca.", this.nume);}

public void se_joaca(string jucaria) //nu permite redefinire18

{Console.WriteLine("{0} se joaca cu {1}.", this.nume, jucaria);}

} //supraîncărcarea metodei se_joaca

class Fetita:Copil

{ public override void se_joaca() //redefinire  comportament polimorfic

{Console.WriteLine("{0} leagana papusa.",this.nume);}

}

class Baiat:Copil

{ public override void se_joaca()

{Console.WriteLine("{0} chinuie pisica.",this.nume);}

}

...

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

Baiat c = new Baiat();c.se_joaca("calculatorul");c.se_joaca(); //polimorfism

Copil c = new Copil();c.se_joaca(); //polimorfism

Pentru a evidenţia mai bine comportamentul polimorfic, propunem 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; }

}

18 Decât cu ajutorul modificatorului new pentru metoda respectivă în clasa derivată

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

10 POO şi Programare vizuală (suport de curs)

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

}

class Fetita:Copil

{ public override void se_joaca()

{Console.WriteLine("{0} leagana papusa.",this.Nume);} //metoda get

}20

1.12. Evenimente şi delegări

Evenimentele sunt membri ai unei clase ce permit clasei sau 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()

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

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.

21 Independent de definiţia clasei Vector

Programarea Orientată Obiect (POO) 11

static void Main(string[] args)

{ Vector x;

do {

x =new Vector();x.scrie();

if (x.aranj(f1))Console.WriteLine("Monoton descrescator");

if (x.aranj(f2))Console.WriteLine("Monoton crescator");

} while (Console.ReadKey(true).KeyCar!=’\x001B’); //Escape

}

Revenind la evenimente, descriem pe scurt un exemplu teoretic 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 realizaeză de fapt activearea tuturor metodelor adăugate la E.

Care credeţi că sunt motivele pentru care apelăm la evenimente în acest caz, când pare

mult mai simplu să apelăm direct metoda M la orice interschimbare?

1.13. Interfeţe

Interfeţele sunt foarte importante în programarea orientată pe obiecte, deoarece permit

utilizarea polimorfismului într-un sens mai extins.O interfaţă este o componentă a aplicaţiei,

asemănătoare unei clase, ce declară prin membrii săi (metode, 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#.

22 De exmplu indicii componentelor interschimbate

23 A se observa că evenimentul în sine este anonim, doar delegatul asociat are nume

24 într-o atribuire de felul x.E+=new [tip_delegat](M)

VENITURI

(din produse, din

chirii, din dobânzi,

dividende)

• calc()

AVERE

Proprietate Bani

Imobiliara Bun Depunere Investiţie Credit_primit

Teren

Imobil

B_inchiriat

Productiv

Neproductiv

De_folosinţă

I_inchiriat

Mobilier

Altul

Actiune

Cotă

Credit_acordat

12 POO şi Programare vizuală (suport de curs)

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 depunere la

bancă, putem determina venitul total:

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

I_inchiriat casa = new I_inchiriat();Depunere dep=new Depunere();

Venit[] venituri = new Venit()[4];

venituri[0] = act1; venituri[1] = act2;

venituri[2] = casa; venituri[3] = dep;

...

int t=0;

for(i=0;i<4;i++) t+=v[i].calc();

Găsiţi două motive pentru care interfaţa VENIT şi rezovarea de mai sus oferă o soluţie

mai bună decât: t=act1.calc()+act2.calc()+casa.calc()+dep.calc().

1.14. Fire de execuţie

Programarea prelucrărilor unei aplicaţii pe mai multe fire de execuţie (multithreading)

presupune ”descompunerea” ansamblului de prelucrări în secvenţe, unele dintre ele

”planificându-se” a fi prelucrate paralel (cvasi-simultan) de către procesor în vederea utilizării

eficiente a acestuia.

Schema alăturată este o posibilă

planificare a procesului de calcul al

expresiei a

∗

(b+c)-b

∗

b, unde a, b şi c sunt

nişte matrice pătrate ale căror

componente se găsesc în fişiere separate.

În orice punct al prelucrării de pe un fir de execuţie se poate genera un nou fir (thread)

căruia i se asociază un subprogram cu ajutorul unui delegat. În exemplul următor, care

utilizează spaţiul System.Threading, afişarea succesivă a unor secvenţe de 1 şi de 2

demonstrază ”comutarea” executării de pe un fir pe altul la intervale relativ constante de timp:

static void scrie2()

{ for (int i = 1; i <=300; i++)Console.Write('2');}

static void Main(string[] args)

{ ThreadStart delegat = new ThreadStart(scrie2);

Thread fir = new Thread(delegat);

fir.Start();

for (int i = 1; i <= 500; i++) Console.Write('1');

Console.ReadKey();}

Spaţiul Threading mai oferă facilităţi de schimbare a priorităţilor prelucrărilor din fire

paralele, de delimitare a secvenţelor critice, de aşteptare şi semnalizare folosind semafoare

etc. O clasă sigilată folosită curent în aplicaţii (Timer) permite implementarea unui ceas care

funcţionează pe un fir paralel cu aplicaţia curentă şi care, la intervale de timp ce se pot seta,

generează un eveniment (Tick) ”sesizat” şi exploatat de prelucrarea din firul principal.

25 Acele clase care ”aderă” la o interfaţă spunem că ”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

citire b

citire c Xb∗bYb+c

Za∗Y UZ-X

citire a

Platforma .NET 13

2. Platforma .NET

2.1. Prezentare

.NET este un cadru (framework) de dezvoltare software unitară care permite realizarea,

distribuirea şi rularea 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ă înpreună cu sistemul de operare Windows.

De fapt, .NET 2.0 vine cu Windows Server 2003 şi Windows XP SP2 şi se poate instala pe

versiunile anterioare, 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 aplicatii 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.)

2.2. .NET Framework

Componenta .NET Framework stă la baza tehnologiei .NET, este ultima interfaţă între

aplicaţiile .NET şi sistemul de operare şi actualmente conţine:

• Limbajele C#, VB.NET, C++ şi J#. Pentru a fi integrate în platforma .NET toate aceste

limbaje respectă nişte specificaţii OOP numite Common Type System (CTS). Ele au

ca elemente de bază: clase, interfeţe, delegări, tipuri valoare şi referinţă, iar ca

mecanisme: moştenire, polimorfism şi tratarea excepţiilor.

• Platforma comună de executare a programelor numită Common Language Runtime

(CLR), utilizată de toate cele 4 limbaje.

• Ansamblul de biblioteci necesare în realizarea aplicaţiilor 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 WINDOWS\Microsoft.

NET\Framework\V2.0….

(corespunzător versiunii instalate)

FCL

Framework Base Classes

(

securitate

fire de execu

colec

ii etc.

)

Common Language Runtime

(

exece

pţ

validări de ti

uri

com

ilatoare JIT

)

Data and XML classes

(

ADO.NET

SQL

XML etc.

)

Servicii WEB Formulare

CLR

14 POO şi Programare vizuală (suport de curs)

2.3. Compilarea programelor

Un program scris îıntr-unul dintre limbajele .NET conform Common Language

Specification (CLS) este compilat în Microsoft Intermediate Language (MSIL sau IL). Codul

astfel obţinut are extensia exe, dar nu este direct executabil, ci respectă formatul unic MSIL.

CLR include o maşină virtuală asemănătoare cu o maşină Java, ce 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 într-un program scris în alt limbaj.

În plus, CLR se ocupă de gestionarea automată a memoriei (un mecanism

implementat în platforma .NET fiind acela de eliberare automată a zonelor de memorie

asociate unor date devenite inutile – Garbage Collection).

Ca un element de portabilitate, trebuie spus că CTS are o arhitectură ce permite

rularea 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 ).

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 (INCAPSULARE, MOSTENIRE,

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

}

Limbajul C# 15

Dacă se salvează fişierul primul.cs, în directorul WINDOWS\Microsoft.NET\Framework\V2.0,

atunci scriind la linia de comandă: csc primul.cs se va obţine fişierul primul.exe direct

executabil pe o platformă .NET.

3.3. Crearea aplicaţiilor consolă

Pentru a realiza aplicaţii în mediul de dezvoltare Visual Studio, trebuie să instalăm o

versiune a acestuia, eventual versiunea free Microsoft Visual C# 2005 Express Edition de

la adresa http://msdn.microsoft.com/vstudio/express/downloads/default.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 asistati

de IntelliSense, ajutorul contextual.

Compilarea programului se realizează cu

ajutorul opţiunii Build Solution (F6) din meniul

Build. Posibilele erori de compilare sunt listate

în fereastra Error List. Efectuând dublu click pe

fiecare eroare în parte, cursorul din program se

poziţionează pe linia conţinând eroarea.

Rularea programului se poate realiza în

mai multe moduri: rapid fără asistenţă de

depanare (Start Without Debugging Shift+F5) ,

rapid cu asistenţă de depanare (Start

Debugging F5 sau cu butonul din bara de

instrumente), rulare pas cu pas (Step Into F11

şi Step Over F12) sau rulare rapidă până la linia

marcată ca punct de întrerupere (Toggle

Breakpoint F9 pe linia respectivă şi apoi Start

Debugging F5). Încetarea urmăririi pas cu pas

(Stop Debugging Shift+F5) permite ieşirea din

modul depanare şi revenirea la modul normal de

lucru. Toate opţiunile de rulare şi depanare se

găsesc în meniul Debug al meniului.

Fereastra de cod şi ferestrele auxiliare ce ne

ajută în etapa de editare pot fi vizualizate alegând

opţiunea corespunzătoare din meniul View.

Ferestrele auxiliare utile în etapa de depanare se

pot vizualiza alegând opţiunea corespunzătoare

din meniul Debug/Windows.

16 POO şi Programare vizuală (suport de curs)

3.4. Structura unui program C#

Să începem cu exemplul clasic “Hello World” adaptat la limbajul C#:

1 using System;

3 namespace HelloWorld

4 {

5 class Program

6 {

7 static void Main()

8 {

9 Console.WriteLine("Hello World!");

10 }

11 }

12 }

O aplicatie C# este formată din una sau mai multe clase, grupate în spaţii de nume

(namespaces). Un spaţiu de nume cuprinde mai multe clase cu nume diferite având

funcţionalităţi înrudite. Două clase pot avea acelaşi nume cu condiţia ca ele să fie 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 imbricate. 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.Writeln reprezintă apelul metodei Writeln

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 parţi ale unui

aceeaşi spaţiu de nume se pot regăsi în mai multe assembly-uri. Pentru o aplicaţie consolă,

ca şi pentru o aplicaţie Windows de altfel, este obligatoriu ca una (şi numai una) dintre clasele

aplicaţiei să conţină un „punct de intrare” (entry point), şi anume metoda (funcţia) Main.

Să comentăm programul de mai sus:

linia 1: este o directivă care specifică faptul că se vor folosi clase incluse în spaţiul de nume

System. În cazul nostru se va folosi clasa Console.

linia 3: spaţiul nostru de nume

linia 5: orice program C# este alcătuit din una sau mai multe clase

linia 7: metoda Main, „punctul de intrare” în program

linia 9: clasa Console, amintită mai sus, este folosită pentru operaţiile de intrare/ieşire. Aici

se apelează metoda WriteLine din acestă clasă, pentru afişarea mesajului dorit pe ecran.

3.5. Sintaxa limbajului

Ca şi limbajul C++ cu care se înrudeşte, limbajul C# are un 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.

27 Este un termen folosit un pic echivoc şi provenit din traduceriea cuvântului ”token”

Limbajul C# 17

Comentarii

• comentariu pe un rând prin folosirea // Tot ce urmează după caracterele // sunt

considerate, din acel loc, până la sfârşitul rândului drept comentariu

// 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 as base bool break

byte case catch char checked

class const continue decimal default

delegate do double else enum

event explicit extern false finally

fixed float for foreach goto

if implicit in int interface

internal is lock long namespace

new null object operator out

override params private protected public

readonly ref return sbyte sealed

short sizeof stackalloc static string

struct switch this throw true

try typeof uint ulong unchecked

unsafe ushort using virtual void

volatile while

Simbolurile lexicale reprezentând constante, regulile de formare a expresiilor,

separatorii de liste, delimitatorii de instrucţiuni, de blocuri de instrucţiuni, de şiruri de

caractere etc. sunt în mare aceiaşi ca şi în cazul limbajului C++.

3.6. Tipuri de date

În C# există două categorii de tipuri de date:

• tipuri valoare

 tipul simple: byte, char, int, float etc.

 tipul enumerare - enum

 tipul structură - struct

18 POO şi Programare vizuală (suport de curs)

• tipuri referinţă

 tipul clasă - class

 tipul interfaţă - interface

 tipul delegat - delegate

 tipul tablou - array

Toate tipurile de date sunt derivate din tipul System.Object

Toate tipurile valoare sunt derivate din clasa System.ValueType, derivată la rândul ei

din clasa Object (alias pentru System.Object).

Limbajul C# conţine un set de tipuri predefinite (int, bool etc.) şi permite definirea

unor tipuri proprii (enum, struct, class etc.).

Tipuri simple predefinite

Tip Descriere Domeniul de valori

object rădăcina oricărui tip

string secvenţă de caractere Unicode

sbyte tip întreg cu semn, pe 8 biţi -128; 127

short tip întreg cu semn, pe 16 biţi -32768; 32767

int tip întreg cu semn pe, 32 biţi -2147483648; 21447483647

long tip întreg cu semn, pe 64 de biţi -9223372036854775808;

9223372036854775807

byte tip întreg fără semn, pe 8 biţi 0; 255

ushort tip întreg fără semn, pe 16 biţi 0; 65535

uint tip întreg fără semn, pe 32 biţi 0; 4294967295

ulong tip întreg fără semn, pe 64 biţi 0; 18446744073709551615

float tip cu virgulă mobilă, simplă precizie, pe

32 biţi (8 pentru exponent, 24 pentru

mantisă)

-3.402823E+38; 3.402823E+38

double tip cu virgulă mobilă, dublă precizie, pe

64 biţi (11 pentru exponent, 53 -mantisa) -1.79769313486232E+308;

1.79769313486232E+308

bool tip boolean -

79228162514264337593543950335;

79228162514264337593543950335

char tip caracter din setul Unicode, pe 16 biţi

decimal tip zecimal, pe 128 biţi (96 pentru

mantisă), 28 de cifre semnificative

O valoare se asignează după următoarele reguli:

Sufix Tip

nu are int, uint, long, ulong

u, U uint, ulong

L, L long, ulong

ul, lu, Ul, lU, UL, LU, Lu ulong

Exemple:

string s = “Salut!” float g = 1.234F;

long a = 10; double h = 1.234;

long b = 13L; double i = 1.234D;

ulong c = 12; bool cond1 = true;

ulong d = 15U; bool cond2 = false;

ulong e = 16L; decimal j = 1.234M;

ulong f = 17UL;

Limbajul C# 19

Tipul enumerare

Tipul enumerare este un tip de finit de utilizator. Acest tip 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,

}

Exemplu:

using System;

namespace tipulEnum

{

class Program

{

enum lunaAnului

{

Ianuarie = 1,

Februarie, Martie, Aprilie, Mai, Iunie, Iulie,

August, Septembrie, Octombrie, Noiembrie, Decembrie

}

static void Main(string[] args)

{

Console.WriteLine("Luna Mai este a ",

(int)lunaAnului.Mai + "a luna din an.");

Console.ReadLine();

}

În urma rulării programului se afişează mesajul :

Luna Mai este a 5 a luna din an.

Tablouri

Declararea unui tablou unidimensional:

Tip[] nume;

Prin aceasta, nu se alocă spaţiu pentru memorare. Pentru a putea reţine date în

structura de tip tablou, este necesară o operaţie de instanţiere:

nume = new Tip[NumarElemente];

Declararea, instanţierea şi chiar iniţializarea tabloului se pot face în aceeaşi instrucţiune:

Exemplu:

int[] v = new int[] {1,2,3}; sau

int[] v = {1,2,3}; //new este implicit

20 POO şi Programare vizuală (suport de curs)

În cazul tablourilor cu mai multe dimensiuni facem distincţie între tablouri regulate şi

tablouri neregulate (tablouri de tablouri)

Declarare în cazul tablourilor regulate bidimensionale:

Tip[,] nume;

Intanţiere:

nume = new Tip[Linii,Coloane];

Acces:

nume[indice1,indice2]

Exemple:

int[,] mat = new int[,] {{1,2,3},{4,5,6},{7,8,9}}; sau

int[,] mat = {{1,2,3},{4,5,6},{7,8,9}};

Declarare în cazul tablourilor neregulate bidimensionale:

Tip[][] nume;

Intanţiere:

nume = new Tip[Linii],[];

nume[0]=new Tip[Coloane1]

...

nume[Linii-1]=new Tip[ColoaneLinii-1]

Acces:

nume[indice1][indice2]

Exemple:

int[][] mat = new int[][] {

new int[3] {1,2,3},

new int[2] {4,5},

new int[4] {7,8,9,1}

}; sau

int[][] mat={new int[3] {1,2,3},new int[2] {4,5},new int[4] {7,8,9,1}};

Şiruri de caractere

Se definesc două tipuri de şiruri:

• regulate

• de tip „verbatim”

Tipul regulat conţine între ghilimele zero sau mai multe caractere, inclusiv secvenţe escape.

Secvenţele escape permit reprezentarea caracterelor care nu au reprezentare grafică

precum şi reprezentarea unor caractere speciale: backslash, caracterul apostrof, etc.

Secvenţă

escape Efect

\’ apostrof

\” ghilimele

\\ backslash

\0 null

\a alarmă

\b backspace

\f form feed – pagină nouă

\n new line – linie nouă

\r carriage return – început de rând

\t horizontal tab – tab orizontal

\u caracter unicode

\v vertical tab – tab vertical

\x caracter hexazecimal

Limbajul C# 21

În cazul în care folosim multe secvenţe escape, putem utiliza şirurile verbatim. Aceste şiruri

pot să conţină orice fel de caractere, inclusiv caracterul EOLN. Ele se folosesc în special în

cazul în care dorim să facem referiri la fişiere şi la regiştri. Un astfel de şir începe

întotdeauna cu simbolul’@’ înaintea ghilimelelor de început.

Exemplu:

using System;

namespace SiruriDeCaractere

{

class Program

{

static void Main(string[] args)

{

string a = "un sir de caractere";

string b = "linia unu \nlinia doi";

string c = @"linia unu

linia doi";

string d="c:\\exemple\\unu.cs";

string e = @"c:\exemple\unu.cs";

Console.WriteLine(a); Console.WriteLine(b);

Console.WriteLine(c); Console.WriteLine(d);

Console.WriteLine(e); Console.ReadLine();

}

Programul va avea ieşirea

un sir de caractere

linia unu

linia doi

linia unu

linia doi

c:\exemple\unu.cs

3.7. Conversii

Conversii numerice

În C# există două tipuri de conversii numerice:

• implicite

• explicite.

Conversia implicită se efectuează (automat) doar dacă nu este afectată valoarea

convertită. Regulile de conversie implicită sunt descrise de tabelul următor:

din în

sbyte short, int, long, float, double, decimal

byte short, ushort, int, uint, long, ulong, float, double, decimal

short int, long, float, double, decimal

ushort int, uint, long, ulong, float, double, decimal

int long, float, double, decimal

uint long, ulong, float, double, decimal

long float, double, decimal

char ushort, int, uint, long, ulong, float, double, decimal

float double

ulong float, double, decimal

Conversia explicită se realizează prin intermediul unei expresii cast, atunci când nu

există posibilitatea unei conversii implicite.

Exemplu:

int i=Console.Read(); char c;

c=char(i);

22 POO şi Programare vizuală (suport de curs)

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

int i = 13;

object ob = i; //boxing implicit

Prin conversia de tip unboxing, obiectul ob poate fi asignat variabilei întregi i:

int i=13;

object ob = i; //boxing implicit

i = (int)ob; //unboxing explicit

3.8. Constante

În C# există două modalităţi de declarare a constantelor: folosind const sau folosind

modificatorul readonly. Constantele declarate cu const trebuie să fie iniţializate la

declararea lor.

Exemple:

const int x; //gresit, constanta nu a fost initializata

const int x = 13; //corect

3.9. Variabile

O variabilă în C# poate să conţină fie o valoare a unui tip 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 Operatori Asociativi-tate

0 Primar ( ) [ ] f() . x++ x-- new typeof sizeof

checked unchecked ->

→

1 Unar + - ! ~ ++x --x (tip) true false & sizeof →

2 Multiplicativ * / % →

3 Aditiv + - →

4 De deplasare << >> →

5 Relaţional < > <= >= is as →

6 De egalitate == != →

Limbajul C# 23

7 AND (SI) logic & →

8 XOR (SAU

exclusiv) logic ^ →

9 OR (SAU) logic | →

10 AND (SI)

condiţional && →

11 OR (SAU)

condiţional || →

12 Condiţional ?: ←

13 De atribuire = *= /= %= += -= ^= &= <<= >>= |= ←

3.11. Colecţii

O colecţie în C# este o clasă specializată pentru memorarea şi regăsirea rapidă a

informaţiilor. Ea implementează metode specifice de actualizare dinamică colecţiei, de

căutare şi de enumerare a datelor. Cel mai des folosite sunt colecţiile de obiecte şi colecţiile

generice (vezi capitolul 5.1) cum ar fi liste, stive, hash-uri. Aceste clase pot fi derivate pentru

a obţine colecţii specializate care se potrivesc cel mai bine necesităţilor de memorare a

datelor specifice unei aplicaţii. Colecţiile sunt definite în spaţiul System.Collection. Metodele

uzuale ale claselor din spaţiul Collection sunt: Add, Remove, IndexOf, Sort, Reverse,

CopyToArray, Find, Foreach etc.

3.12. Instrucţunea foreach

Cum instrucţiunile de apel, atribuire, decizie, selecţie şi trei structuri repetitive coincid

ca formă şi funcţionalitate cu cele din C, ne oprim sumar numai unora dintre noile structuri de

control specifice limbajului C#.

Instrucţiunea foreach enumeră elementele dintr-o colecţie sau dintr-un tablou,

executând un bloc de instrucţiuni pentru fiecare element al colecţiei sau tabloului. La fiecare

iteraţie, elementul curent al colecţiei este de tip readonly, neputând fi modificat. Amintim că

în instrucţiunea repetitivă foreach se pot utiliza cu exact aceeaşi funcţionalitate

instrucţiunile de salt break şi continue.

instrucţiunea se utilizează curent în aplicaţii pentru tablouri şi colecţii de obiecte28.

Pentru a vedea cum acţionează o vom compara cu instrucţiunea cunoscută for. Fie

vectorul nume format din şiruri de caractere:

string[] nume={“Ana”, Ionel”, “Maria”};

Să afişam acest şir folosind instrucţiunea for:

for(int i=0; i<nume.Length; i++)

{

Console.Write(“{0} ”, nume[i]);

}

Acelaşi rezultat îl obţinem folosind instrucţiunea foreach:

foreach (string copil in nume)

{

Console.Write(“{0} ”, copil);

}

3.13. Instrucţiunile try-catch-finally şi throw

Prin excepţie se înţelege un obiect care încapsulează informaţii despre situaţii

anormale în funcţionarea unui program. Ea se foloseşte pentru a semnala contextul în care

28 de exemplu, pentru prelucrarea sistematică a tuturor componentlelor unei ferestre (butoane,

liste, casete de text etc.)

24 POO şi Programare vizuală (suport de curs)

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;

class tryCatch

{

static void Main(string[] args)

{ string s;

Console.Write("Numele fisierului:");

Console.Readln(s);

try

{

File.OpenRead(s);

}

catch (FileNotFoundException a)

{

Console.WriteLine(a.ToString());

}

catch (PathTooLongException b)

{

Console.WriteLine(b.ToString());

}

finally

{

Console.WriteLine("Programul s-a sfarsit");

Console.ReadLine();

}

Alteori putem simula prin program o stare de eroare ”aruncând” o excepţie

(instrucţiunea throw) sau putem profita de mecanismul de tratare a erorilor pentru a

implementa un sistem de validare a datelor prin generarea unei excepţii proprii pe care, de

asemenea, o ”aruncăm” în momentul neîndeplinirii unor condiţii puse asupra datelor.

Clasa System.Exception şi derivate ale acesteia servesc la tratarea adecvată şi

diversificată a excepţiilor.

Exemplu: Considerăm clasele Copil, Fetita, Baiat definite fragmentat în capitolul 1. O

posibilitate de validare la adăugara unui copil este aceea care generează o excepţie proprie

la depăşirea dimensiunii vectorului static copii:

public static void adaug_copil(Copil c)

{

if (nr_copii < nr_max)

copii[nr_copii++] = c;

else throw new Exception("Prea multi copii");

}

Programare vizuală 25

4. Programare vizuală

4.1. Concepte de bază ale programării vizuale

Programarea vizuală trebuie privită ca un mod de proiectare a unui program prin

operare directă asupra unui set de elemente grafice (de aici 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 textual29, 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, click, hint etc.)

Realizarea unei aplicaţii vizuale nu constă doar în desenare şi aranjare de controale, ci

presupune în principal stabilirea unor decizii arhitecturale30, decizii ce au la bază unul dintre

modelele arhitecturale de bază:

a) Modelul arhitectural orientat pe date.

Acest model nu este orientat pe obiecte, timpul de dezvoltare al unei 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 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.

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

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

26 POO şi Programare vizuală (suport de curs)

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ţeles31 şi de învăţat de către utilizator şi să permită

acestuia să efectueze operaţiile dorite în timp cât mai scurt. În acest sens, este vitală

culegerea de informaţii despre utilizatorii finali ai aplicaţ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 („template”) 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.

4.2. Mediul de dezvoltare Visual C#

Mediul de dezvoltare Microsoft Visual C# dispune de instrumente specializate de

proiectare, ceea ce permite crearea aplicaţiilor în mod 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

vizualiza şi eventual schimba proprietăţile obiectelor.

Toolbox conţine controale standard drag-

and-drop şi componente utilizate în crearea aplicaţiei

Windows. Controalele sunt grupate în categoriile

logice din imaginea alăturată.

Designer, Code, Solution Explorer şi celelalte se află grupate în meniul View.

La crearea unei noi aplicaţii vizuale, Visual Studio.NET generează un spaţiu de nume

ce conţine clasa statică Program, cu metoda statică ce constituie punctul de intrare (de

lansare) a aplicaţiei:

static void Main()

{ ...

Application.Run(new Form1());

}

Clasa Application este responsabilă cu administrarea unei aplicaţii Windows, punând la

dispoziţie proprietăţi pentru a obţine informaţii despre aplicaţie, metode de lucru cu aplicaţia

şi altele. Toate metodele şi proprietăţile clasei Application sunt statice. Metoda Run invocată

31 Î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.

Programare vizuală 27

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.

4.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 realizază instanţieri ale

claselor Button, MenuStrip, Timer etc. (orice plasăm noi în fereastră) şi adaugă referinţele

acestor obiecte la colecţia de controale ale ferestrei.

Dacă modelul de fereastră reprezintă ferestra principală a 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, Click etc.).

O fereastră poate fi activată cu form.Show() sau cu form.ShowDialog(), metoda a

doua permiţând ca revenirea în fereastra din care a fost 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

From.ShowDialog() cu proprietarul ca argument.

F_nou form = new F_nou();form.ShowDialog(this);

Vizibilitatea unui formular poate fi setată folosind metodele Hide sau Show. Pentru a

ascunde un formular putem folosi :

this.Hide(); // setarea propietatii Visible indirect sau

this.Visible = false; // setarea propietatii Visible direct

Printre cele mai uzuale proprietăţi ale form-urilor, reamintim:

• StartPosition determină poziţia ferestrei atunci când aceasta apare prima dată, poziţie

ce poate fi setată Manual sau poate fi centrată pe desktop (CenterScreen), stabilită de

Windows, formularul având dimensiunile şi locaţia stabilite de programator

(WindowsDefaultLocation) sau Windows-ul va stabili dimensiunea iniţială şi locaţia

pentru formular (WindowsDefaultBounds) sau, centrat pe formularul care l-a afişat

(CenterParent) atunci când formularul va fi afişat modal.

28 POO şi Programare vizuală (suport de curs)

• 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ă propietăţ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 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 opacitate32

• 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 click î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 click 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.

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

Programare vizuală 29

• FormClosed apare când formularul este închis.

• FormClosing apare când formularul se va inchide ca rezultat al acţiunii 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 click pe alt formular al aplicatiei.

4.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:

• Controale de actiune (de exemplu button) care, atunci când sunt acţionate, se poate

executa o prelucrare. De exemplu, cel mai important eveniment pentru Button este Click

(desemnând acţiunea click stânga pe buton).

În exemplul PV1 se adaugă pe formular două butoane şi o casetă

text. Apăsarea primului buton va determina afişarea textului din TextBox

într-un MessageBox iar apăsarea celui de-al doilea buton va închide

închide aplicaţia. După adăugarea celor două butoane şi a casetei text a

fost schimbat textul afişat pe cele două butoane au fost scrise funcţiile

de tratare a evenimentului Click pentru cele două butoane:

private void button1_Click(object sender, System.EventArgs e)

{ MessageBox.Show(textBox1.Text);}

private void button2_Click(object sender, System.EventArgs e)

{ Form1.ActiveForm.Dispose();}

• Controale valoare (label, textbox, picturebox) care arată utilizatorului o informaţie

(text, imagine).

Label este folosit pentru plasarea de text pe un formular. Textul 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.

private void button1_Click(object sender, System.EventArgs e)

{if (button1.BackColor== Color.IndianRed) button1.BackColor=Color.Yellow;

else button1.BackColor= Color.IndianRed;}

30 POO şi Programare vizuală (suport de curs)

private void button4_MouseEnter(object sender, System.EventArgs e)

{button4.BackColor=Color.YellowGreen;button4.Text="Butoane apasate";}

private void button4_MouseLeave(object sender, System.EventArgs e)

{textBox1.Visible=false;button4.Text="Starea butoanelor";

button4.BackColor=Color.Orange;}

private void button4_Click(object sender, System.EventArgs e)

{textBox1.Visible=true;textBox1.Text="";

if( button1.BackColor==Color.Yellow)textBox1.Text=textBox1.Text+'A';

if( button2.BackColor==Color.Yellow)textBox1.Text=textBox1.Text+'B';

if( button3.BackColor==Color.Yellow)textBox1.Text=textBox1.Text+'C';

}

Exerciţiu Modificaţi aplicaţia precedentă astfel încât să avem un singur eveniment

button_Click, diferenţierea fiind făcută de parametrul sender.

Exerciţiu ( Password) Adăugaţi pe un formular o casetă text în care să introduceţi un

şir de caractere şi apoi verificaţi dacă acesta coincide cu o 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:

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.

Programare vizuală 31

private void etichetaC_LinkClicked (object sender,

LinkLabelLinkClickedEventArgs e )

{ etichetaC.LinkVisited = true;

System.Diagnostics.Process.Start( @"C:\" );}

private void etichetaI_LinkClicked( object sender,

LinkLabelLinkClickedEventArgs e )

{etichetaI.LinkVisited = true;

System.Diagnostics.Process.Start("IExplore",

"http://www.microsoft.com/romania/" );}

private void etichetaN_LinkClicked( object sender,

LinkLabelLinkClickedEventArgs e )

{etichetaN.LinkVisited = true;

System.Diagnostics.Process.Start( "notepad" );}

Exerciţiu (Memorator) Construiţi o aplicaţie care să conţină patru legături către 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.

32 POO şi Programare vizuală (suport de curs)

ImageList desene_animate = new System.Windows.Forms.ImageList();

private void contruieste_lista_Click(object sender, System.EventArgs e)

{ // Configureaza lista

desene_animate.ColorDepth =System.Windows.Forms.ColorDepth.Depth8Bit;

desene_animate.ImageSize = new System.Drawing.Size(60, 60);

desene_animate.Images.Clear();

string[] gif_uri = Directory.GetFiles("C:\\Imagini", "*.gif");

// se construieste un obiect Imagine pentru fiecare fisier si se adauga la ImageList.

foreach (string fisier_gif in gif_uri)

{Bitmap desen= new Bitmap (fisier_gif);

desene_animate.Images.Add(desen);pictureBox2.Image=desen;}

Graphics g = this.CreateGraphics();

// Deseneaza fiecare imagine utilizand metoda ImageList.Draw()

for (int i = 0; i < desene_animate.Images.Count; i++)

desene_animate.Draw(g, 60 + i * 60, 60, i);

g.Dispose();

}

Exerciţiu (Thumbnails) Afişaţi într-o ferestră conţinutul folder-ului curent în mod View-

Thumbnails.

• MonthCalendar afişează un calendar prin care se poate selecta o dată (zi, luna, an) în

mod grafic. Proprietăţile mai importante sunt: MinDate, MaxDate, TodayDate ce

reprezintă data minimă/maximă selectabilă şi data curentă (care apare afişată diferenţiat

sau nu în funcţie de valorile proprietăţilor ShowToday,ShowTodayCircle. Există 2

evenimente pe care controlul le expune: DateSelected şi DateChanged. În rutinele de

tratare a acestor evenimente, programatorul are acces la un obiect de tipul

DateRangeEventArgs care conţine proprietăţile Start şi End (reprezentând intervalul de

timp selectat).

Formularul din aplicaţia PV7 conţine un

calendar pentru care putem selecta un interval de

maximum 30 de zile, sunt afişate săptămânile şi

ziua curentă. Intervalul selectat se afişează prin

intermediul unei etichete. Dacă se selectează o

dată atunci aceasta va fi adăugată ca item într-un

ComboBox (orice dată poate apărea cel mult o

dată în listă).

După adăugarea celor 3 controale pe formular, stabilim proprietăţile pentru

monthCalendar1 (ShowWeekNumber-True, MaxSelectionCount-30, etc.) şi precizăm ce

se execută atunci când selectăm un interval de timp:

private void monthCalendar1_DateSelected(object sender,

System.Windows.Forms.DateRangeEventArgs e)

{ this.label1.Text = "Interval selectat: Start = "

+e.Start.ToShortDateString() + " : End = "

+ e.End.ToShortDateString();

if (e.Start.ToShortDateString()==e.End.ToShortDateString())

{String x=e.Start.ToShortDateString();

if(!(comboBox1.Items.Contains(x)))

comboBox1.Items.Add(e.End.ToShortDateString());}

}

• DateTimePicker este un control care (ca şi MonthCalendar) se poate utiliza pentru a

selecta o dată. La click 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.

Programare vizuală 33

Exerciţiu (Formular) Contruiţi un formular de introducere a datelor necesare realizării

unei adrese de e-mail. Data naşterii va fi selectată direct 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

click. La expandare se afişează numele complet,

data ultimei accesări şi, în cazul fişierelor,

dimensiunea.

Controlul lista_fisiere este de tip ListView.

Funcţia ConstruiesteHeader permite

stabilirea celor trei coloane de afişat.

private void ConstruiesteHeader()

{ColumnHeader colHead;colHead = new ColumnHeader();

colHead.Text = "Nume fisier";

this.lista_fisiere.Columns.Add(colHead);

colHead = new ColumnHeader();colHead.Text = "Dimensiune";

his.lista_fisiere.Columns.Add(colHead);

colHead = new ColumnHeader();colHead.Text = "Ultima accesare";

this.lista_fisiere.Columns.Add(colHead);

}

Pentru item-ul selectat se afişează mai întâi folderele şi după aceea fişierele. Pentru aceasta

trebuie să determinăm conţinutul acestuia:

ListViewItem lvi;

ListViewItem.ListViewSubItem lvsi;

this.calea_curenta.Text = radacina + "(Doublu Click pe folder)";

System.IO.DirectoryInfo dir = new System.IO.DirectoryInfo(radacina);

DirectoryInfo[] dirs = dir.GetDirectories();

FileInfo[] files = dir.GetFiles();

să ştergem vechiul conţinut al listei:

this.lista_fisiere.Items.Clear();

this.lista_fisiere.BeginUpdate();

şi să adăugăm fiecare nou item ( coloana a doua este vidă în cazul foldere-lor):

foreach (System.IO.DirectoryInfo fi in dirs)

{ lvi = new ListViewItem();lvi.Text = fi.Name;

lvi.ImageIndex = 1; lvi.Tag = fi.FullName;

lvsi = new ListViewItem.ListViewSubItem();

lvsi.Text = "";lvi.SubItems.Add(lvsi);

lvsi = new ListViewItem.ListViewSubItem();

lvsi.Text = fi.LastAccessTime.ToString();

lvi.SubItems.Add(lvsi); this.lista_fisiere.Items.Add(lvi);

}

Exerciţiu (Ordonare) Modificaţi aplicaţia anterioară astfel încât apăsarea pe numele

unei coloane să determine afişarea informaţiilor ordonate după criteriul specificat (nume,

dimensiune, data).

• Controale ”de control” al executării (Timer) sau de dialog (OpenFileDialog,

SaveFileDialog, ColorDialog, FontDialog, ContextMenu).

34 POO şi Programare vizuală (suport de curs)

• Grupuri de controale Toolbar (ToolStrip) afişează o bară de butoane în partea de sus a

unui formular. Se pot introduce vizual butoane (printr-un 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)

{ this.richTextBox1.Font= fd.Font;

this.richTextBox1.ForeColor=fd.Color;

}

ColorDialog cd = new ColorDialog();

cd.AllowFullOpen = true;cd.Color = Color.DarkBlue;

if(cd.ShowDialog() == System.Windows.Forms.DialogResult.OK)

this.richTextBox1.ForeColor = cd.Color;

Mutarea toolbar-ul este dirijată de evenimentele produse atunci când apăsăm butonul de

mouse şi/sau ne deplasăm pe suprafaţa ferestrei.

private void toolBar1_MouseDown(object sender, MouseEventArgs e)

{ // am apasat butonul de mouse pe toolbar

am_apasat = true;

forma_deplasata = new Point(e.X, e.Y); toolBar1.Capture = true;}

private void toolBar1_MouseUp(object sender, MouseEventArgs e)

{ am_apasat = false;toolBar1.Capture = false;}

private void toolBar1_MouseMove(object sender, MouseEventArgs e)

{ if (am_apasat)

{ if(toolBar1.Dock == DockStyle.Top || toolBar1.Dock == DockStyle.Left)

{ // daca depaseste atunci duc in stanga sus

if (forma_deplasata.X < (e.X-20) || forma_deplasata.Y < (e.Y-20))

{ am_apasat = false;// Disconect toolbar

toolBar1.Dock = DockStyle.None;

toolBar1.Location = new Point(10, 10);

toolBar1.Size = new Size(200, 45);

toolBar1.BorderStyle = BorderStyle.FixedSingle;

}

else if (toolBar1.Dock == DockStyle.None)

{toolBar1.Left = e.X + toolBar1.Left - forma_deplasata.X;

toolBar1.Top = e.Y + toolBar1.Top - forma_deplasata.Y;

if (toolBar1.Top < 5 || toolBar1.Top>this.Size.Height-20)

{ am_apasat = false;toolBar1.Dock = DockStyle.Top;

toolBar1.BorderStyle = BorderStyle.Fixed3D;}

else if (toolBar1.Left < 5 || toolBar1.Left > this.Size.Width - 20)

{ am_apasat = false;toolBar1.Dock = DockStyle.Left;

toolBar1.BorderStyle = BorderStyle.Fixed3D;

}}}

}

Exerciţiu (Editor) Realizaţi un editor de texte care conţină un control toolBar cu butoanele

uzuale.

Programare vizuală 35

• Controale container (GroupBox, Panel, TabControl) sunt controale ce pot conţine alte

controale.

Aplicaţia PV10 simulează lansarea unei

comenzi către un magazin de jucării. Se utilizează 4

pagini de Tab pentru a simula selectarea unor opţiuni

ce se pot grupa pe categorii.

Exerciţiu (Magazin) Dezvoltaţi aplicaţia

precedentă astfel încât pe o pagină să se afişeze

modelele disponibile (imagine+detalii) şi să se

permită selectarea mai multor obiecte. Ultima pagină

reprezintă coşul de cumpărături.

• Grupuri de controale tip Meniu (MenuStrip, ContextMenuStrip etc.)

Un formular poate afişa un singur meniu principal la un moment dat, meniul asociat

iniţial fiind specificat prin propietatea Form.MainMenuStrip. Meniul care este afişat de către

un formular poate fi schimbat dinamic la rulare :

switch(cond) { case cond1:this.MainMenuStrip = this.mainMenu1;break;

case cond2:this.MainMenuStrip = this.mainMenu2;

}

unde mainMenu1 şi mainMenu2 sunt obiecte de tip MenuStrip. Editarea unui astfel de

obiect se poate face utilizând Menu Designer. Clasa MenuStrip are o colecţie de MenuItem

care conţine 0 sau mai multe obiecte de tip MenuItem. Fiecare dintre aceste obiecte de tip

MenuItem are 0 sau mai multe obiecte de tip MenuItem, care vor constitui noul nivel de itemi

(Ex: File New,Save, Open, Close, Exit).

Propietăţile Checked si RadioCheck indică itemul selectat, Enabled and Visible

determină dacă un item poate fi sau nu selectat sau vizibil, Shortcut permite asignarea unei

combinaţii de taste pentru selectarea unui item al meniului şi Text memorează textul care va

fi afişat pentru respectivul item al meniului.

Evenimentul Click are loc când un utilizator apasă un item al meniului.

Exemplul PV11 permite, prin

intermediul unui meniu, scrierea unui fisier

Notpad, afişarea continutului acestuia într-

o casetă text, schimbarea fontului şi culorii

de afişare, ştergerea conţinutului casetei,

afişarea unor informaţii teoretice precum şi

Help dinamic. Au fost definite chei de

acces rapid pentru accesarea

componentelor meniului.

File New permite scrierea unui fişier notepad nou

System.Diagnostics.Process.Start( "notepad" );

File Open selectează şi afişează în caseta text conţinutul unui fişier text.

OpenFileDialog of = new OpenFileDialog();

of.Filter = "Text Files (*.txt)|*.txt";

of.Title = "Fisiere Text";

if (of.ShowDialog() == DialogResult.Cancel)return;

richTextBox1.Text="";richTextBox1.Visible=true;

FileStream strm;

try{strm = new FileStream (of.FileName, FileMode.Open, FileAccess.Read);

StreamReader rdr = new StreamReader (strm);

while (rdr.Peek() >= 0){string str = rdr.ReadLine ();

richTextBox1.Text=richTextBox1.Text+" "+str;}

}

catch (Exception){MessageBox.Show ("Error opening file", "File Error",

MessageBoxButtons.OK, MessageBoxIcon.Exclamation);}

File Close şterge conţinutul casetei text, File Exit închide aplicaţia

36 POO şi Programare vizuală (suport de curs)

Window  Font şi Window Color permit stabilirea fontului/culorii textului afişat.

Help DinamicHelp accesează System.Diagnostics.Process.Start("IExplore",

"http://msdn2.microsoft.com/en-us/default.aspx");

Help About PV afişează în caseta text informaţii despre implementarea unui menu.

Exerciţiu (Fisiere) Contruiţi un menu care să permită efectuarea operaţiilor uzuale cu fişiere.

4.5. System.Drawing

Spaţiul System.Drawing conţine tipuri care permit realizarea unor desene 2D şi au

rol deosebit în proiectarea interfeţelor grafice.

Un obiect de tip Point este reprezentat prin coordonatele unui punct într-un spaţiul

bidimensional (exemplu: Point myPoint = new Point(1,2);)

Point este utilizat frecvent nu numai pentru desene, ci şi 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 aleatoare şi emite sunete cu frecvenţă aleatoare.

Random x = new Random();

Console.Beep(300 + x.Next(1000), 150);

Graphics g = e.Graphics;

i = 1 + x.Next(30);

p=new Pen(System.Drawing.Color.FromArgb(x.Next(256),x.Next(256),x.Next(256)))

g.DrawEllipse(p, x.Next(100), x.Next(100), i, i);

Console.Sleep(200);

În exemplul PV13 se construieşte o pictogramă pe baza unei imagini.

Image thumbnail;

private void Thumbnails_Load(object sender, EventArgs e)

{ try{Image img = Image.FromFile("C:\\Imagini\\catel.jpg");

int latime=100, inaltime=100;

thumbnail=img.GetThumbnailImage(latime, inaltime,null,

IntPtr.Zero);}

catch{MessageBox.Show("Nu exista fisierul");}

}

private void Thumbnails_Paint(object sender, PaintEventArgs e)

{e.Graphics.DrawImage(thumbnail, 10, 10);}

Programare vizuală 37

4.6. Validarea informaţiilor de la utilizator

Înainte ca informaţiile de la utilizator să fie preluate şi 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 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 fisier text, pentru fiecare item se precizează punctajul, enunţul, răspunsul corect,

distractorii şi o imagine asociată enunţului (dacă există). După efectuarea testului se

afişează rezultatul obţinut şi statistica răspunsurilor.

38 POO şi Programare vizuală (suport de curs)

5. Aplicaţii orientate pe date

5.1. Structuri de date

Construirea unei aplicaţii ce gestionează un volum mare de date necesită o atenţie

particulară privind organizarea acestor date. Sursele de date trebuie şi ele integrate

corespunzător într-o aplicaţie OOP. Faptul că o stivă din clasa Stack este implementată ca

vector sau nu, este de mică importanţă pentru programatorul pe platformă .NET. Dar pentru

operaţiile executate de o aplicaţie ce monitorizează traficul dintr-o gară de triaj, este

important de ştiut dacă trebuie memorat sau nu un istoric al acestor operaţii, dacă sunt

folosite informaţiile de acest tip în prelucrări ulterioare sau sunt doar listate sub formă de

rapoarte periodice, etc. Dacă datele trebuie exportate către alte aplicaţii, atunci se pune

problema formatului în care vor fi salvate. Pentru colecţiile consistente de date care suferă

prelucrări ample şi frecvente se pune problema suportului de memorare astfel încât să

suporte tehnici de acces rapide etc.

5.2. Colecţii de date

Colecţia, în general, reprezintă un ansamblu bine structurat de componente de acelaşi

tip, ansamblu ce permite identificarea rapidă a oricărei componente din colecţie. Definiţia

este aplicabilă şi colecţiilor de date. Uneori, cloecţiile de date sunt percepute ca date externe

(aflate pe harddisc sau alte suporturi de memorare), dar asta nu exclude posibilitatea

organizării datelor interne sub forma unor colecţii. În C#, colecţiile sunt clase specializate

aparţinând spaţiului System.Collection. Despre colecţii am mai vorbit în cadrul capitolului 3.11.

Aducem unele completări în cele ce urmează vorbind despre structuri generice de date.

Atributul ”generic” se referă la proprietatea de a referi o întreagă categorie de obiecte.

Clasele, structurile, metodele, interfeţele, delegaţii şi metodele pot fi generice, adică pot fi

concepute astfel încât să depindă de unul sau mai multe tipuri de date pe care acestea le

memorează sau manipulează.

De exemplu, la declararea unei clase obişnuite, noi stabilim elementele fixe ale

acesteia: numele şi tipurile datelor, numele metodelor33 şi altor componente ce formează

clasa respectivă. Pentru o funcţie (metodă) obişnuită sunt definite atât numele, cât şi tipul

parametrilor funcţiei34.

C# introduce, începând de la versiunea 2.0, parametrizarea tipurilor, adică posibilitatea

declarării unor clase, metode etc. în care tipul datelor manevrate nu este cunoscut decât la

apel. Acest tip de date constituie un parametru al clasei, metodei etc.

Vom defini în mod obişnuit şi, paralel, în mod generic clasa Stiva (amintită şi în

capitolul 1.1) pentru a pune în evidenţă diferenţele induse de modul de lucru ... generic:

class Stiva

{

int[] st = new int[10]; int vf;

public Stiva() { vf = -1; }

public void Push(int x)

{ st[++vf] = x; }

public int Pop()

{ return st[vf--]; }35

public void scrie()

{for (int i = 0; i <= vf; i++)

Console.Write(st[i]);

Console.WriteLine();

}

class Stiva<T>

{

T[] st = new T[10]; int vf;

public Stiva() { vf = -1; }

public void Push(T x)

{ st[++vf] = x; }

public T Pop()35

{ return st[vf--]; }

public void scrie()

{for (int i = 0; i <= vf; i++)

Console.Write(st[i]);

Console.WriteLine();

}

33 A nu se confunda capacitatea de a defini mai multe metode cu acelaşi nume cu faptul că

numele este bine determinat. A spune că numele nu este definit ar presupune un fel de declarare cu

numele ... şi abia la apel să se stabilească ce nume este scris în loc de ... ☺

34 Numărul parametrilor este şi el bine definit, deşi funcţiile care au definit un parametru de tip

tablou, permit apelul cu un număr variabil de parametri efectivi.

35 Versiuni mai vechi de C nu execută conform aşteptărilor returul valorii cu postincrementare.

Aplicaţii orientate pe date 39

...

static void Main(string[] args)

{

Stiva s = new Stiva();

s.Push(7);s.Push(5); s.scrie();

Console.WriteLine(„Ex{0},s.Pop());

s.scrie();

s.Push(7); s.scrie();

Console.WriteLine("Ex{0}",s.Pop());

s.scrie();

}

...

static void Main(string[] args)

{

Stiva<int> s = new Stiva<int>();

s.Push(7); s.Push(5); s.scrie();

Console.WriteLine("Ex{0}",s.Pop());

s.scrie();

s.Push(7); s.scrie();

Console.WriteLine("Ex{0}",s.Pop());

s.scrie();

}

Dintre clasele generice ”predefinite”, cele mai des utilizate sunt colecţiile generice.

Astfel, clasele şi interfeţele din spaţiul System.Collection.Generic permit organizarea

datelor proprii, indiferent de tipul acestora, în structuri specifice cum ar fi: liste (List), liste

dublu înlănţuite (LinkedList), stive (Stack), cozi (Queue), dicţionare (Dictionary) etc.

De exemplu, dorim să gestionăm un ansamblu de ferestre asemănătoare, instanţiate

dintr-o aceeaşi clasă MyForm (să zicem) derivată din System.Windows.Forms.Form.

Putem memora în program sau ca element static al clasei MyForm o structură de tip listă:

List<MyForm> fer=new List<MyForm>()

La crearea oricărei ferestre f de tipul MyForm (MyForm f=new MyForm(); f.Show();)

se adaugă referinţa ferestrei în lista fer (fer.Add(f)). Analog, la închiderea ferestrei, se va

elimina referinţa acesteia din listă (fer.Remove(f)).

Exerciţiu: Presupunem că implementăm o aplicaţie în care se completează datele

unui pacient într-o fereastră. Pentru a nu încărca ferestra curentă, aceasta este proiectată să

conţină butoane ce permit deschiderea unor ferestre secundare pentru completarea unor

subcategorii de date (istoricul suferinţelor cronice, analize efectuate, adresa detaliată etc.).

De exemplu, în fereastră se completează numele pacientului, iar apoi, apăsând pe butonul

Adresa, se deschide o fereastră ce permite completarea câmpurilor ce formează adresa, la

închiderea ferestrei revenind la fereastra principală. Desigur, şi o fereastră secundară poate

avea la rândul ei butoane pentru alte ferestre secundare în raport cu aceasta. Stabiliţi ce tip

de structură generică se poate utiliza pentru gestiunea ferestrelor deschise la un moment

dat36.

5.3. ADO.NET

ADO.NET (ActiveX Data Objects) reprezintă o parte componentă a nucleului .NET

Framework ce permite accesarea şi manipularea datelor. Amintim că o sursă de date poate

fi: un fişier text, un fişier Excel sau XML, o bază de date Dbase, Access, SQL etc. Lucrul cu o

sursă de date se poate face fie conectat, fie deconectat de la sursa de date. ADO.NET

implementează clase ce oferă servicii atât pentru lucrul în stil deconectat cât şi conectat,

oferă instrumentele de utilizare şi reprezentare XML, de combinare a datelor din diferite

surse şi de diferite tipuri (pe bază mecanismenlor de reprezentare comună implementate de

.NET. Maniera de lucru deconectată recomandă metoda ca fiind mai eficientă în proiectarea

aplicaţiilor pentru Internet decât alte tehnologii cum ar fi ADO sau ODBC.

Deoarece există mai multe tipuri de baze de date e nevoie de câte o bibliotecă

specializată de clase şi interfeţe care să implementeze un ”protocol” specific pentru fiecare.

5.4. Conectarea la o sursă de date

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

36 punem accentul pe faptul că ferestrele sunt modale

40 POO şi Programare vizuală (suport de curs)

Pentru deschiderea unei conexiuni prin program se poate instanţia un obiect de tip

conexiune, precizându-i ca parametru un şir de caractere conţinând date despre conexiune.

Dăm două exemple de conectare la o sursă de date SQL respectiv Access:

using System.Data.SqlClient;

...

SqlConnection co = new SqlConnection(@"Data Source=serverBD;

Database=scoala;User ID=elev;Password=madonna");

co.Open();

...

using System.Data.OleDb;

...

OleDbConnection con =

new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;

Data Source=C:\Date\scoala.mdb");

cn.Open();

...

Proprietăţile unei conexiuni

ConnectionString (String): conţine un string cu o succesiune de parametri de forma

parametru=valoare, despărţiţi prin ;. Parametrii pot fi:

• provider: 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

• Data Source: se specifică numele serverului de baze de date sau numele fişierului de date

• Initial Catalog (Database): specifică numele bazei de date. Baza de date trebuie să se

găsească pe serverul dat în Data Source.

• User ID: specifica un nume de cont de utilizator care are acces de logare la server.

• Password: specifică parola contului de mai sus.

ConnectionTimeout (int): specifică numărul de secunde pentru care un obiect de

conexiune poate să aştepre pentru realizarea conectării la 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ă.

SqlConnection cn = new SqlConnection("Data Source=serverBD;

Database=scoala;User ID=elev;Password=madonna; Connect Timeout=30");

Database (string): returnează numele bazei de date la care s–a făcut conectarea. Este

necesară pentru a arăta unui utilizator care este baza de date pe care se face operarea

Provider (string): returnează furnizorul

ServerVersion (string): returnează versiunea de server la care s–a făcut conectarea.

State (enumerare de componente ConnectionState): returnează starea curentă a conexiunii.

Valorile posibile: Broken, Closed, Connecting, Executing, Fetching, Open.

Metodele unei conexiuni

Open(): deschide o conexiune la baza de date

Close() şi Dispose(): închid conexiunea şi eliberează toate resursele alocate pentru ea

BeginTransaction(): pentru executarea unei tranzacţii pe baza de date; la sfârşit se

apelează Commit() sau Rollback().

ChangeDatabase(): se modifică baza de date la care se vor face conexiunile. Noua bază

de date trebuie să existe pe acelaşi server ca şi precedenta.

CreateCommand(): creează o comandă (un obiect de tip Command) validă asociată

conexiunii curente.

Evenimentele unei conexiuni

StateChange: apare atunci când se schimbă starea conexiunii. Handlerul corespunzător (de

tipul delegat StateChangeEventHandler) spune între ce stări s-a făcut tranziţia.

InfoMessage: apare când furnizorul trimite un avertisment sau un mesaj către client.

Aplicaţii orientate pe date 41

5.5. Executarea unei comenzi SQL

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.

SqlConnection co = new SqlConnection(@"Data Source=serverBD;

Database=scoala;User ID=elev;Password=madonna");

co.Open();

SqlCommand cmd = new SqlCommand("SELECT * FROM ELEVI", con);

Proprietăţile unei comenzi

CommandText (String): conţine comanda SQL sau numele procedurii stocate care se

execută pe sursa de date.

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.

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)

Connection (System. Data. [Provider].PrefixConnection): conţine obiectul de tip conexiune

folosit pentru legarea la sursa de date.

Parameters (System.Data.[Provider].PrefixParameterCollection): returnează o colecţie de

parametri care s-au transmis comenzii;

Transaction (System.Data.[Provider].PrefixTransaction): permite accesul la obiectul de tip

tranzacţie care se cere a fi executat pe sursa de date.

Metodele unei comenzi

Constructori: SqlCommand() sau SqlCommand(string CommandText) sau

SqlCommand(string CommandText, SqlConnection con ) sau

SqlCommand(string CommandText,SqlConnection con,SqlTransaction trans)

Cancel() opreşte o comandă aflată în executare.

Dispose() distruge obiectul comandă.

ExecuteNonQuery()execută o comandă care nu returnează un set de date din baza de

date; dacă comanda a fost de tip INSERT, UPDATE, DELETE, se returnează numărul de

înregistrări afectate.

SqlCommand cmd = new SqlCommand();

cmd.CommandText = "DELETE FROM elevi WHERE nume = ’BARBU’";

cmd.Connection = con;

Console.WriteLine(cmd.ExecuteNonQuery().ToString()); //câte înreg.s-au şters

ExecuteReader() execută comanda şi returnează un obiect de tip DataReader

SqlCommand cmd = new SqlCommand("SELECT * FROM elevi",con);

SqlDataReader reader = cmd.ExecuteReader();

while(reader.Read())

{ Console.WriteLine("{0} - {1}",

reader.GetString(0),reader.GetString(1));

}

reader.Close();

Metoda ExecuteReader() mai are un argument opţional, CommandBehavior care descrie

rezultatele şi efectul asupra bazei de date: CloseConnection (conexiunea este închisă atunci

când obiectul DataReader este închis), KeyInfo (returneză informaţie despre coloane şi cheia

primară), SchemaOnly (returneză doar informaţie despre coloane), SequentialAccess (pentru

manevrarea valorilor binare cu GetChars() sau GetBytes()), SingleResult (se returnează un

singur set de rezultate), SingleRow (se returnează o singură linie).

42 POO şi Programare vizuală (suport de curs)

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

SqlCommand cmd = new SqlCommand("SELECT COUNT(*) FROM elevi",con);

SqlDataReader reader = cmd.ExecuteScalar();

Console.WriteLine(reader.GetString(0));

ExecuteXmlReader() returnează un obiect de tipul XmlReader obţinut prin interogare

SqlCommand CMD=

new SqlCommand("SELECT * FROM elevi FOR XML MATE,EXAMEN", con);

System.Xml.XmlReader myXR = CMD.ExecuteXmlReader();

5.6. Seturi de date

Datele pot fi explorate în mod conectat (cu ajutorul unor obiecte din categoria

DataReader), sau pot fi preluate de la sursă (dintr-un obiect din categoria DataAdapter) şi

înglobate în 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.

Un obiect DeatReader nu are constructor, ci se obţine cu ajutorul unui obiect de tip

Command şi prin apelul metodei ExecuteReader() (vezi exemplul de la pagina 41, jos).

Evident, pe toată durata lucrului cu un obiect de tip DataReader, conexiunea trebuie să fie

activă. Toate clasele DataReader (SqlDataReader, OleDbDataReader etc.) implementează

interfaţa IDataReader.

Proprietăţi:

IsClosed, HasRows, Item (indexator de câmpuri) şi FieldCount

Metode:

Close() închidere obiectului şi eliberarea resurselor; trebuie să preceadă închiderea conxiunii

GetBoolean(), GetByte(), GetChar(), GetDateTime(), GetDecimal(),

GetDouble(), GetFloat(), GetInt16(), GetInt32(), GetInt64(), GetValue(),

GetString() returnează valoarea unui câmp specificat, din înergistrarea curentă

GetBytes(), GetChars() citirea unor octeţi/caractere dintr–un câmp de date binar

GetDataTypeName(), GetName() returnează tipul/numele câmpului specificat

IsDBNull() returnează true dacă în câmpul specificat prin index este o valoare NULL

NextResult()determină trecerea la următorul rezultat stocat în obiect (vezi exemplul)

Read() determină trecerea la următoarea înregistrare, returnând false numai dacă aceasta

nu există; de reţinut că iniţial poziţia curentă este înaintea primei întrgistrări.

SqlCommand cmd=new SqlCommand("select * from elevi;select * from profi", conn );

conn.Open ();

SqlDataReader reader = cmd.ExecuteReader ();

do {

while ( reader.Read () )

{Console.WriteLine ( "{0}\t\t{1}", reader[0], reader[1] );}

} while ( reader.NextResult () );

Folosirea combinată a obiectelor DataAdapter şi DataSet permite operaţii de selectare,

ştergere, modificare şi adăugare la baza de date. Clasele DataAdapter generează obiecte

care funcţionează ca o interfaţă între sursa de date şi 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);

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

Aplicaţii orientate pe date 43

Proprietăţile unui DataAdapter

DeleteCommand, InsertCommand, SelectCommand, UpdateCommand (Command),

conţin comenzile ce se execută pentru selectarea sau modificarea datelor în sursa de date.

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.

Metodele unui DataAdapter

Constructoril: SqlDataAdapter(); sau SqlDataAdapter(obiect_comanda); sau

SqlDataAdapter(string_comanda, conexiune);

Fill() permite umplerea unei tabele dintr–un obiect DataSet cu date. Permite specificarea

obiectului DataSet în care se depun datele, eventual a numelui tablei din acest DataSet,

numărul de înregistrare cu care să se înceapă popularea (prima având indicele 0) şi numărul

de înregistrări care urmează a fi aduse.

Update() permite transmiterea modificărilor efectuate într–un DataSet către baza de date.

Structura unui DataSet

Un DataSet este format din Tables (colecţie formată din obiecte de tip DataTable; DataTable

este compus la rândul lui dintr-o colecţie de DataRow şi DataColumn), Relations (colecţie de

obiecte de tip DataRelation pentru memorarea legăturilor părinte–copil) şi ExtendedProperties

ce conţine proprietăţi definite de utilizator.

Scenariul uzual de lucru cu datele dintr-o tabelă conţine urmă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.

5.7. Proiectarea vizuală a seturilor de date

Mediul de dezvoltare Visual Studio dispune de instrumente puternice şi sugestive

pentru utilizarea bazelor de date în aplicaţii. Conceptual, în spatele unei ferestre în care

lucrăm cu date preluate dintr-una sau mai mlte tabele ale unei baze de date se află obiectele

din categoriile Connection, Command, DataAdapter şi DataSet prezentate. ”La vedere” se

află controale de tip DataGridView, sau TableGridView, BindingNavigator etc.

Meniul Data şi fereastra auxiliară Data Sources ne sunt foarte utile în lucrul cu surse de

date externe.

Să urmărim un scenariu de realizare a unei aplicaţii simple cu o

fereastră în care putem vizualiza date dintr-o tabelă, putem 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 harddiscul local.

• Selectăm tabelele care ne interesează din baza de date şi

câmpurile din cadrul tabelei ce vor fi reţinute în TableAdapter

(din categoria DataAdapter)

• Când operaţiunea se încheie, date relative la baza de date la

care ne-am conectat sunt integrate în proiect şi pictograma, ca

şi structura bazei de date apar în fereastra Data Source

44 POO şi Programare vizuală (suport de curs)

• Prin "tragerea" unor obiecte din

fereastra Data Sources în ferea-

stra noastră nouă, se creează

automat obiecte specifice. În

partea de jos a figurii se pot

observa obiectele de tip

Dataset, TableAdapter, Binding-

Source, BindingNavigator şi, în

fereastră, TableGridView

BindingNavigator este un tip ce

permite, prin instanţiere, construirea

barei de navigare ce permite

operaţii de deplasare, editare,

ştergere şi adăugare în tabel.

Să observăm că reprezentarea vizuală a fiecărui obiect este

înzestrată cu o săgetă în partea de sus, în dreapta. Un click

pe această săgeată activează un meniu contextual cu lista

principalelor operaţii ce se pot efectua cu obiectul respectiv.

Meniul contextual asociat grilei în care vor fi vizualizate datele

permite configurarea modului de lucru cu grila (sursa de date,

operaţiile permise şi altele).

În timpul rulării aplicaţiei,

bara de navigare şi elementele

vizuale ale grilei permit operaţiile

de bază cu înregistrările bazei

de date. Operaţiile care modifică

baza de date trebuie să fie

definitivate prin salvarea noilor

date .

Programarea Web

cu ASP .Net 2.0

CUPRINS

CUPRINS ................................................................................................................................................. 49

1. ARHITECTURI SOFTWARE .................................................................................................... 51

1.1. MODELUL CLIENT- SERVER.......................................................................................................... 51

1.2. MODELUL MULTI-STRAT.............................................................................................................. 52

1.3. APLICAŢII ORIENTATE SPRE SERVICII ........................................................................................... 54

2. PROTOCOALE DE REŢEA ....................................................................................................... 57

2.1. MODELUL DE REFERINŢĂ TCP/IP................................................................................................ 57

2.2. PROTOCOLUL HTTP.................................................................................................................... 58

3. PROGRAMAREA CLIENT - SIDE............................................................................................ 62

3.1. ELEMENTE AVANSATE DE HTML................................................................................................ 62

3.1.1. Tabele................................................................................................................................. 62

3.1.2. Frames (cadre) în HTML................................................................................................... 65

3.1.3. Formulare .......................................................................................................................... 68

3.2. XML ........................................................................................................................................... 72

3.3. CSS - CASCADING STYLE SHEETS (FOI DE STIL IN CASCADA)...................................................... 73

4. PROGRAMAREA SERVER – SIDE CU ASP.NET.................................................................. 76

4.1. SERVERUL IIS.............................................................................................................................. 76

4.2. CARACTERISTICI ALE ASP SI ASP .NET..................................................................................... 76

4.3. CREAREA DE APLICAŢII WEB FOLOSIND ASP.NET..................................................................... 78

4.3.1. Configurarea masinii de lucru pentru proiecte ASP.NET.................................................. 78

4.3.2. Proiectele ASP.NET in Visual Studio .NET cu C# ............................................................. 78

4.3.3. Formulare în ASP.NET ...................................................................................................... 79

4.3.4. Controale în ASP.NET ....................................................................................................... 80

4.3.5. Pastrarea informatiilor ...................................................................................................... 81

4.3.6. Navigarea intre Forms cu pastrarea informatiilor ............................................................ 81

4.3.7. Securitatea în ASP.NET ..................................................................................................... 82

4.4. ADO.NET................................................................................................................................... 83

4.4.1. Obiectele ADO.Net............................................................................................................. 85

4.4.2. Configurare, mentenanta ................................................................................................... 86

5. REFERINTE ................................................................................................................................. 88

Arhitecturi Software 51

1. Arhitecturi Software

Dezvoltarea de aplicatii / programe software implica mai multe etape, programarea

(scrierea de cod propriu-zisa) fiind doar una dintre ele si poate să insemne doar aproximatv

25% din timpul total de dezvoltare. Etapele sunt:

• Analiza cerintelor

• Proiectarea de nivel inalt (arhitectura)

• Proiectarea componentelor

• Implementarea

• Testarea si validarea

• Punerea in functiune

• Intretinerea

Proiectarea la nivel inalt, sau stabilirea arhitecturii are o importanta deosebita in acest

proces, deoarece alegerile facute aici determina derularea viitoarelor etape, implicit limitele

intre care se va programa efectiv aplicatia. Arhitectura este un model scris al unui sistem,

care poate fi utilizat la construirea sistemului propriu-zis, şi este formata din:

• Definirea scopului sistemului.

• Modelul de date.

• Diagrame de flux de date.

• Fluxul interfetei cu utilizatorul.

Exista mai multe modele arhitecturale, dintre care putem aminti:

• Modelul client-server

• Multi-strat

Aplicatii orientate pe servicii

1.1. Modelul client- server

Termenul client-server este folosit prima data in 1980, legat de calculatoarele dîntr-o

reţea. Arhitectura software client-server este o infrastructură modulară, bazată pe mesaje.

Un client este definit ca un solicitant de servicii, iar serverul ca un prestator de servicii. O

masină (un calculator) poate fi in acelaşi timp atât client cât şi server în funcţie de aplicaţiile

rulate. Precursoare ale modelului client-server au fost arhitecturile de tip mainframe si file

sharing. Propozitia precedenta nu e prea corecta, pentru ca se refera strict la modul in care

erau utilizate calculatoarele in trecut.

Urmatoarele paragrafe nu prea au legatura cu modelul arhitectural client-server, ci tot

cu modul in care erau utilizate calculatoarele. In plus, sunt si niste erori in exprimare, cum ar

fi „Comunicarea între client şi server se realizează prin intermediul interogarilor SQL sau a

RPC (Remote Procedure Calls)”. Una este SQL si cu totul altceva este RPC – nu prea au

legatura.

În arhitectura mainframe aplicaţiile rulau pe un computer principal, iar utilizatorii

interacţionau cu acesta prîntr-un terminal (blind terminal) care trimitea informaţiile tastate.

Limitarile acestui tip de arhitectură constau în faptul că nu asigurau o interfată grafica cu

utilizatorul (GUI) si nu puteau accesa baze de date distribuite in diferite locaţii.

Reţelele de calculatoare iniţiale se bazau pe arhitectura de tip partajare de fisiere

(file-sharing) , în care serverul download-a fisiere (dîntr-o locaţie partajata) pe calculatorul

gazda. Aici se rulau aplicaţiile (datele si procesarea lor). Viteza de lucru era scazută, iar

numarul maxim de utilizatori, care accesa simultan resursele partajate, era mic.

Ca urmare a limitărilor arhitecturii de tip file-sharing, a aparut modelul client – server,

în care serverul de fisiere a fost inlocuit de un server de baze de date. Prin utilizarea unui

sistem de gestiune a bazelor de date (SGBD) se raspundea in mod direct cererilor

utilizatorului. De asemenea se reduce traficul in retea prin returnarea unui raspuns la o

interogare, faţă de returnarea unui întreg fisier. Apar si interfatele grafice (GUI) pentru

52 Programare Web (suport de curs)

accesul la baza de date partajata (interfeţe numite şi front-end). Comunicarea între client şi

server se realizează prin intermediul interogarilor SQL sau a RPC (Remote Procedure Calls).

Mecanismul RPC a aparut cu mai bine de doua decenii in urma in lumea Unix si este

folosit in construcţia de aplicaţii distribuite pe sisteme eterogene, avand la baza tehnologiile

Internet. O aplicatie RPC va consta dintr-un client si un server, serverul fiind localizat pe

maşina care execută procedura. Aplicaţia client comunica prin reţea – via TCP/IP – cu

procedura de pe calculatorul aflat la distanţă, transmiţând argumentele şi recepţionând

rezultatele. Clientul şi serverul se execută ca două procese separate care pot rula pe

calculatoare diferite din reţea.

In loc de ultimele 4 paragrafe, as insista mai mult pe niste modele client-server foarte

cunoscute, cum ar fi:

• Windows Live Messenger. In acest caz, clientul este programul pe care il

avem instalat pe calculatorul personal cei care dorim să comunicam prin

acest serviciu. Server-ul (in acest caz programul server este instalat de fapt

mai multe masini) este programul „central” care:

o Are baza de date a utilizatorilor, adica a celor care au conturi de

Windows Live.

o Primeste mesaje de la clienti si le „ruteaza”, adica le trimite mai

departe catre clientul / clientii (in cazul unei conferinte) destinatari.

o Tine evidenta sesiunilor clientilor, adica „stie” tot timpul cand cineva

este logged in, cu Live Messenger pornit, respectiv cand iese.

o Etc.

Solutiile de email, cum ar fi de exemplu serverul Exchange + Outlook.

1.2. Modelul multi-strat

Arhitecturile multi-strat sunt acelea in care fiecare strat logic:

• Are un scop precis.

• Isi vede numai de propriile responsabilitati.

• Stie exact modul de comunicare / interactiune cu straturile adiacente.

In astfel de arhitecturi, este usor de separat anumite functionalitati care nu ar trebui

să depinda unele de altele. De exemplu, interfata cu utilizatorul, sau mai bine spus clasele /

paginile care formeaza aceasta interfata, nu trebuie să „stie” cum anume se realizeaza

accesul la baza de date. Cu alte cuvinte, in clasele / paginile in care se afiseaza informatii,

Modelul

client-

serve

Arhitecturi Software 53

nu este nevoie să avem cod care lucreaza cu baza de date. Astfel, se realizeaza o separare

logica benefica pentru intelegerea mai usoara si intretinerea mai eficienta a software-ului.

De exemplu, putem avea arhitecturi multi-strat pe 2 nivele (two tier architecture), in

care să spunem ca interfaţa cu utilizatorul este situată pe calculatorul utilizatorului sub forma

unei aplicatii Windows (deci instalata pe calculator), iar sistemul de gestiune a bazelor de

date pe un calculator mai puternic (server) care deserveste mai multi clienti

O alta arhitectura pe 2 nivele poate fi o aplicatie web in care interfata propriu-zisa

(paginile, codul de afisare a informatiilor si de captare a datelor introduse de utilizator) este

instalata pe un server, iar baza de date pe un alt server.

În arhitectura multi-strat pe 3 nivele (three tier architecture) se introduce un nou strat

intre interfaţă şi SGBD. Interfaţa cu utilizatorul , procesarea, stocarea si accesarea datelor

sunt module separate, care se pot situa pe platforme diferite. Acest model asigură o

flexibilitate sporita, fiecare modul putand fi modificat independent de celelalte. Spre exemplu

schimbarea sistemului de operare din Windows în Linux poate afecta doar modulul de

interfaţă.

De obicei, interfaţa cu utilizatorul rulează pe un alt calculator şi foloseşte o interfaţă

grafica standard (GUI), procesarea logica poate consta din unul sau mai multe module care

ruleaza pe un server de aplicatii, iar SGBD-ul ruleaza pe un server de baze de date sau

mainframe. Stratul de mijloc poate fi format la randul lui din mai multe nivele, caz in care

arhitectura este numită multi strat cu n nivele (n-tier architecture).

Cele 3 nivele sunt:

54 Programare Web (suport de curs)

• Nivelul de prezentare (presentation tier) sau interfaţa cu utilizatorul:

prezentarea rezultatelor sistemului catre utilizator si preluarea de informatii de

la utilizator

• Nivelul logic de procesare (logic tier / business logic tier/ transaction tier) :

funcţionalitatea specifică aplicaţiei.

Nivelul de date (data tier): Interactiunea cu suportul datelor (baze de date, fisiere,

servicii web, etc).

1.3. Aplicaţii orientate spre servicii

Pentru a discuta despre Arhitecturi Orientate pe Servicii (SOA), ar trebui să plecam

mai intai de la definitia acestora. Din pacate nu exista o definitie universal acceptat pentru

SOA. Ceea ce se poate spune in schimb despre acest mode este ca prin intermediul lui se

incearca descrierea unor arhitecturi bazate pe servicii slab interconectate care suporta

modelarea proceselor de business si a necesitatilor utilizatorilor. Resursele aflate într-o

„retea” sunt expuse ca servicii independente care pot fi accesate fara cunostiinte apriori

despre ceea ce rezida in spatele lor: platforma, implementare, algoritmi, etc.

Aceste concepte generice sunt valabile fie ca se vorbeste despre business-uri,

software sau alte tipuri de sisteme de tip consumator-producator.

Dupa cum mentionam anterior, arhitecturile de tip SOA nu impun utilizare unei

anumite tehnologii [precum REST, RPC, DCOM, CORBA sau Servicii Web]. Conceptul cheie

care permite acest lucru este faptul ca serviciile sunt independente, si pot fi apelate într-un

mod standardizat pentru a-si indeplini sarcinile pentru care au fost proiectate si

implementate, fara ca serviciul să fie nevoit să stie in prealabil nimic despre aplicatia care il

invoca, sau ca aplicatia care invoca serviciul să aibă nevoie să inteleaga mecanismele

interne prin care serviciul isi duce la bun sfarsit rolul pentru care a fost definit.

Putem astfel incerca să definim SOA ca fiind: o paradigma pentru organizarea si

utilizarea capabilitatilor distribuite care pot să fie sub controlul unor entitati diferite. Aceasta

paradigma ofera o modalitate uniforma de descoperire si interactioanre.

Conceptul de baza al SOA este aceala de interconectare slaba, realizat prin

constrangeri arhitecturale precum:

- Fiecare serviciu ofera un set de interfete simple si care ofera doar o semantica

generala, si care este accesibila de catre orice producator sau consumator interesat.

- Intre interfetele diferitelor servicii se schimba doar mesaje care respecta o schema

predefinita, dar extensibila, prin intermediul carora se trimite doar continut si nu

descriere comportamentala a sistemului. Cu alte cuvinte mesajul trebuie să aibă o

mare putere de descriere si nu una de „comanda”/instruire.

Pe langa conceptul de interconectare slaba, mai exista si urmatorele concepte

referitoare la principiile unei arhitecturi de tip SOA:

- Incapsularea Serviciului

- Contractul Serviciului – se refera la faptul ca serviciile sunt de acord să comunice pe

baza unui agreement stipulat de catre unul sau mai multe servicii prin intermediul

unor documente descriptive

- Abstractizarea Serviciului – un serviciu expune ceea ce face si nu cum o face

- Refolosirea Serviciului – in sine conceptul se serviciu implica reutilizare. Serviciile au

fost concepte pentru a putea să fie reutilizate.

- Compunerea Serviciilor – colectii de servicii pot să fie coordonate si asambalte astfel

in cat să formeza un nou serviciu, numit un serviciu compus.

- Autonomia Serviciului – un serviciu are control total asupra logicii pe care o

incapsuleaza

- Descoperirea Serviciilor – serviciile sunt concepute astfel incat să isi descrie

functionalitatea catre „exterior”, astfel incat să poata fi gasite si folosite prin

intermediul unor mecanisme de descoperire.

Avand bazele puse pentru conceptul de SOA, in cele ce urmeaza se va incerca

definirea Serviciilor Web pe baza acestor concepte. Serviciile Web nu sunt altceva decât o

Arhitecturi Software 55

modalitate prin care o arhitectura SOA este realizate, folosind un anumit set de protocoale si

restrictii. In cazul concret al Serviciilor Web, urmatoarele doua restrictii sunt impuse:

- Interfetele serviciilor trebuie să fie construite peste protocoale din Internet, precum

HTTP, FTP sau SMTP.

- Exceptand atasamentele binare alea unor mesaje, toata comunicarea intre servicii

trebuie să fie făcută prin mesaje in format XML.

In momentul de fata exista doua mari clase de Servicii Web, si anume: SOAP si

REST. In cele ce urmeaza vom discuta despre Servicii Web de tip SOAP si infrastructuri

oferite de platforma .NET pentru implementarea/dezvoltarea, gazduira, rularea si

mentenanta unor Servicii Web de tip SOAP. Decizia de a descrie mai indetaliu Serviciile

Web de tip SOAP este aceea ca ele sunt recunoscute de piata ca un standard defacto, fapt

vizibil si prin adoptia majoritara a acestora.

SOAP este un acronim pentru Simple Object Access Protocol. Clasa de Servicii Web

de tip SOAP aduce urmatoarele constrangeri fata de cele mentionate mai sus:

- Cu exceptia atasamentelor binare, toate mesajele trebuie să fie transportate prin

intermediul SOAP.

- Descrierea unui Serviciu Web se va face folosind un limbaj de markup numit WSDL –

Web Service Description Language.

- Existenta registrelor UDDI (Universal Description Discovery and Integration) care au

ca scop indexarea Serviciilor Web. UDDI-ul permite interogarea să prin intermediul

SOAP si faciliteaza accesul la WSDL-ul Serviciilor Web pe care le indexeaza.

SOAP nu face altceva decât să defineasca un format pentru mesaje care pot fi

trimise intre servicii web deasupra unui numar de protocoale internet. Cu alte cuvinte, SOAP

se comporta ca un plic care muta continut dintr-un punct in altul.

Pentru exemplificare, mai jos este un mesaj SOAP:

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">

<soap:Body>

</obtineDetaliiCursant >

</soap:Body>

</soap:Envelope>

Se poate observa in exemplul de mai sus structura unui mesaj de tip SOAP:

- Plicul: <soap:Envelope>

- Continutul acestui delimitat de: <soap:Body>

Odata cu dezvoltarea standardelor pentru Servicii Web de tip SOAP (de acum incolo

numit simplu Servicii Web) si cu adoptia lor pe piata, s-a facut simtita nevoia unor standarde

suplimentare pentru a putea exprima concepte precum securitatea, increderea si tranzactiile.

O serie de firme din industria software au dezvoltat in consecinta o suita de standarde

numite colectiv WS-* care trateaza aceste probleme. Telul acestor specificatii este acela de

a oferi sabloane pentru functionalitati avansate ale Serviciilor Web, totodata pastrand

simplitatea nativa a Serviciilor Web. Cea mai importanta trasatura a specificatiilor WS-* este

posibilitatea lor de a fi compuse. Compunearea protocoalelor asociate acestor specificatii

permite o dezvoltare incrementala a Serviciilor Web, pe masura ce functionalitatea lor o cere

(securitate, incredere, atasamente, tranzactii, descoperire, etc.). Individual fiecare

specificatie rezolva o problema izolta, dar ca un compus, ele rezolva probleme de

functionalitate ridicata adesea intalnite in aplicatii distribuite.

Modelul acesta poate fi exprimat schematic astfel:

56 Programare Web (suport de curs)

In cele ce urmeaza se vor prezenta succint produsele din platforma Microsoft care

compun ecosistemul pentru construirea si mentenanta sistemlor distribuite implementate

folosing Servicii Web.

Constructia de Servicii Web se poate realiza

- folosind Microsoft Visual Studio 2005 in colaborare cu platforma .NET 2.0, prin

intermediul carora se pot implementa servicii web care sunt in conformitate cu

standardul WS-Interoperability [WS-I]. Crearea serviciului este facila, partea de

contract fiind generata automat pe partea serviciului, iar partea de proxy fiind

deasemenea generata automat pe partea de client. Suportul pentru descoperire este

deasemenea integrat prin suportarea protocolului UDDI.

- folosind Web Service Enhancements 3.0 [WSE 3.0] in colaborare cu VS2005 si .NET

2.0, se pot realiza Servicii Web care sunt in conformitate cu ultimele specificatii ale

WS-*. WSE 3.0 este oferit ca un pachet care se integreaza perfect cu suita de

dezvoltare VS 2005. WSE 3.0 aduce suport in cadrul platformei .NET 2.0 pentru

XML, SOAP, WSDL, WS-Security, WS-Trust, WS-SecureConversation, WS-

Addressing si MTOM

- folosind platforma .NET 3.0 care aduce un set nou de API-uri printre care si Windows

Communication Foundation, API care permite un model unificat de programare si

rulare a Serviciilor Web folosind limbaje managed, precum C#. WCF aduce suport

integral pentru toate standardele recunoscute cat si cele mai populare adoptate de

piata, numarand astfel urmatoarele:

o pentru trimiterea mesajelor: XML, SOAP, WS-Addressing

o pentru descrierea interfetelor (asa numita MetaData): WSDL, WS-

MetadataExchange, WS-Policy, WS-SecurityPolicy

o pentru securitate: WS-Trust, WS-Security, WS-SecureConversation

o pentru incredere: WS-ReliableMessaging

pentru tranzactii: WS-Coordination si WS-AtomicTransactions

Protocoale de reţea 57

2. Protocoale de reţea

2.1. Modelul de referinţă TCP/IP

Pana în anii 60, comunicarea între computere se realiza greoi prin intermediul liniilor

telefonice. În 1962 Paul Baran şi Donald Davies propun – independent – ideea unui sistem

de comunicare între reţele bazat pe comutarea de pachete – packet switching. Această

arhitectura a fost implementată de ARPANET, o reţea de calculatoare sponsorizată de DoD

(Department of Defence). Arhitectura a devenit cuoscută mai târziu sub denumirea de

modelul de referinţă TCP/IP, după numele celor două protocoale fundamentale utilizate.

Protocolul TCP (Transfer Control Protocol) se refera la modalitatea de transmitere a

informatiei, iar protocolul IP (Internet Protocol) se refera la modealitatea de adresare.

Dată fiind îngrijorarea DoD că o parte din gazde, routere şi porţi de interconectare ar

putea fi distruse la un moment dat, un obiectiv major a fost ca reţeaua să poată supravieţui

pierderii echipamentelor din subreţea, fără a întrerupe conversaţiile existente. Cu alte

cuvinte, DoD dorea ca, atâta timp cât funcţionau maşina sursă şi maşina destinaţie,

conexiunile să rămână intacte, chiar dacă o parte din maşini sau din liniile de transmisie erau

brusc scoase din funcţiune. Mai mult, era nevoie de o arhitectură flexibilă, deoarece se

aveau în vedere aplicaţii cu cerinţe divergente, mergând de la transferul de fişiere până la

transmiterea vorbirii în timp real.

Toate aceste cerinţe au condus la alegerea unei reţele cu comutare de pachete

bazată pe un nivel inter-reţea fără conexiuni. Acest nivel, numit nivelul internet (IP), este

axul pe care se centrează întreaga arhitectură. Rolul său este de a permite gazdelor să

emită pachete în orice reţea şi face ca pachetele să circule independent până la destinaţie.

Pachetele pot chiar să sosească într-o ordine diferită faţă de cea în care au fost trimise, caz

în care rearanjarea cade în sarcina nivelurilor de mai sus (acele nivele ce urmeaza să

proceseze pachetele primite).

Fiecare computer conectat la internet are o adresa de IP unică. Adresele IP sunt sub

forma nnn.nnn.nnn.nnn, unde nnn trebuie să fie un număr între 0 şi 255. Spre exemplu, la

momentul redactarii acestui document, www.microsoft.com are ip-ul 207.46.192.254.

Fiecarui calculator îi este asociată o adresă de loopback 127.0.0.1, care înseamna “acest

calculator”. 127.0.0.1 se mai numeşte şi localhost. În anii `80 au fost conectate la Arpanet un

număr foarte mare de reţele. Această situaţie a determinat, în 1984, crearea sistemului DNS

(Domain Name System), prin intermediul căruia calculatoarele erau organizate în domenii,

punându-se în corespondenţă adresele IP cu numele gazdelor.

Nivelul de transport sau TCP ataşează pachetelor trimise un număr de port al

serviciului destinatar şi direcţionează pachetele care ajung, către o anumită aplicaţie. Fiecare

serviciu comunică pe un anumit port. Porturile sunt numere întregi care permit unui computer

să facă diferenţa între comunicaţiile internet ce au loc la un anumit moment dat. Numerele

porturilor sunt cuprinse intre 0 si 65535 si sunt impartite in doua clase: cele pana la 1024

sunt rezervate pentru sistemul de operare, iar cele peste 1024 sunt disponibile

dezvoltatorilor. Prin prezenta porturilor si deoarece aplicatiile care deservesc diferite servicii

pe un sistem ruleaza pe porturi diferite, putem avea servicii care ruleaza concomitent pe

58 Programare Web (suport de curs)

acelasi calculator. Astfel, pe un sistem (server) pot rula concomitent aplicatii server si pentru

protocolul HTTP cat si pentru protocolul FTP. Un server poate deservi clienti atat ai

serviciului sau HTTP cat si a celui FTP, deoarece poate deosebi pachetele adresate celor

doua servicii pe baza portului catre care sunt trimise. Cele mai comune porturi sunt: FTP :

20/21, Telnet: 23, HTTP: 80, Microsoft SQL Server:1433.

Printre protocoalele de nivel aplicatie, enumeram cateva din cele mai cunoscute:

HTTP, FTP, Telnet, SMTP, SSL, POP3, IMAP, SSH etc.

HTTP (Hyper Text Transfer Protocol) este un protocol client - server în care clienţii

(browserele web) trimit o cerere unui server web. După ce serverul returnează elementele

cerute (imagini, text etc.) conexiunea dintre client şi server este întreruptă. Acest lucru

înseamnă că după ce elementele cerute sunt descarcate pe calculatorul utilizatorului, iar

browserul descoperă ca are nevoie de o alta resursa de pe server, se realizează o nouă

cerere către acesta. Acest lucru înseamnă că HTTP nu este orientate pe conexiune

(connection-oriented).

FTP (File Transfer Protocol) facilitează transferul de fişiere între două calculatoare din

internet.

SMTP (Simple Mail Transfer Protocol) este un protocol folosit pentru schimbul de

mesaje de poştă electronică.

Telnet este un protocol care permite unui utilizator să se conecteze de la un calculator

la altul.

SSL (Secure Socket Layer) este un protocol folosit pentru transmiterea de date text

criptate in internet.

Modelul TCP/IP este înrudit cu modelul de referinţă OSI (Open Systems

Interconnection). Modelul OSI este format din 7 straturi asigurând astfel mai multă

flexibilitate. Acest model nu este folosit însa în practică, rămânând mai mult un model

teoretic. In figura de mai jos se poate vedea sitva de comunicare propusa de modelul

ISO/OSI cu cele 7 nivele ale sale. Nivelul cel mai de jos reprezinta nivelul fizic al retelei, iar

nivelul cel mai de sus reprezinta nivelul aplicatie. In aceasta arhitectura multi-nivel, fiecare

nivel comunica doar cu nivelele adiacente: la transmiterea de date, datele pleaca din nivelul

aplicatiei, iar fiecare nivel comunica doar cu nivelul imediat de sub el; la primirea de date,

fiecare nivel comunica doar cu nivelul imediat de deasupra lui.

2.2. Protocolul HTTP

Unul dintre cele mai importante şi de succes servicii ale Internetului, World-Wide

Web-ul – mai pe scurt Web sau spaţiul WWW, a fost instituit la CERN (Centre Européen

Protocoale de reţea 59

pour la Recherche Nucléaire – Centrul European de Cercetări Nucleare de la Geneva) în

anul 1989. Web – ul a apărut din necesitatea de a permite cercetătorilor răspândiţi în lume

să colaboreze utilizând colecţii de rapoarte, planuri, desene, fotografii şi alte tipuri de

documente aflate într-o continuă dezvoltare.

Comunicaţia dintre clientul web (browserul) şi serverul web are loc în felul următor:

procesul server Web (spre exemplu Microsoft IIS – Internet Information Services) „ascultă”

portul TCP 80 al maşinii gazde pentru a răspunde eventualelor cereri de conexiune venite de

la clienţi. După stabilirea conexiunii TCP, clientul care a iniţiat conexiunea trimite o cerere

(de exemplu un document HTML), la care serverul trimite un răspuns (documentul cerut sau

un mesaj de eroare). După trimiterea răspunsului conexiunea dintre client şi server se

încheie. Cererile clientului şi răspunsurile serverului Web sunt descrise de protocolul HTTP

(Hyper Text Transfer Protocol).

Etapele care se parcurg între cerere şi răspuns sunt:

1. Browserul determina URL – ul cerut de utilizator.

2. Browserul întreabă serverul local DNS adresa IP a maşinii pe care se află pagina

cu URL-ul selectat.

3. Serverul DNS comunică browserului adresa IP cerută.

4. Browserul stabileşte o conexiune TCP cu portul 80 al serverului cu IP – ul obţinut

anterior.

5. Utilizând conexiunea TCP, browserul trimite o comandă GET.

6. Serverul web răspunde trimiţând un fişier HTML.

7. Serverul Web închide conexiunea TCP.

8. Browserul afişează textul din fişierul HTML trimis.

9. Browserul cere şi afişează şi celelalte elemente necesare în pagină (de exemplu

imaginile).

Exemplu de cerere din partea clientului:

GET / HTTP/1.1

Host: www.live.com

Exemplu de răspuns al serverului:

HTTP/1.1 200 OK

Date: Wed, 15 Aug 2007 09:49:56 GMT

Server: Microsoft-IIS/6.0

P3P:CP="BUS CUR CONo FIN IVDo ONL OUR PHY SAMo TELo"

S:WEBA12

X-Powered-By: ASP.NET

X-AspNet-Version: 2.0.50727

Set-Cookie: mktstate=E=&P=&B=; domain=live.com; path=/

Set-Cookie: mkt1=norm=-ro; domain=live.com; path=/

Set-Cookie: mkt2=ui=ro-ro; domain=www.live.com; path=/

Set-Cookie: lastMarket=ro-ro; domain=.live.com; path=/

Set-Cookie: lastMktPath=ro/ro; domain=.live.com; path=/

Set-Cookie: frm=true; domain=.live.com; expires=Mon,

04-Oct-2021 19:00:00 GMT; path=/

Set-Cookie: frm=true; domain=.live.com; expires=Mon,

04-Oct-2021 19:00:00 GMT; path=/

Cache-Control: no-cache

Pragma: no-cache

Expires: -1

Content-Type: text/html; charset=utf-8

Content-Length: 5939

Metodele puse la dispoziţie de protocolul HTTP sunt:

• HEAD – clientul cere numai antetul paginii

60 Programare Web (suport de curs)

• GET - clientul cere serverului să trimită pagina specificată

• POST - trimite date pentru a fi procesate pe server

• PUT – inlocuieşte conţinutul paginii specificate cu datele trimise de client

• DELETE – solicită ştergerea paginii specificate

• TRACE – permite clientului să vadă cum sunt prelucrate mesajele

• OPTIONS – returnează metodele HTTP suportate de server

• CONNECT - converteşte conexiunea de tip cerere într-un tunel TCP/IP , de

obicei pentru a facilita comunicaţii securizate prin SSL (HTTPS).

Formularele HTML sunt folosite pentru ca utilizatorii să introducă date în câmpurile

acestora şi să le transmită serverului Web (utilizând browserul, o conexiune TCP şi

protocolul HTTP).

Cele mai răspândite servere Web sunt :

• IIS (Internet Information Server) de la Microsoft. Este inclus ca parte

componentă a sistemelor de operare Microsoft (Windows NT Server,

Windows 2000 Server şi Windows Server 2003).

Apache (open source). Pentru a transmite date serverului se poate folosi metoda

GET sau metoda POST. Metoda implicită este GET.

Dacă se utilizează GET, datele transmise serverului pot fi vizualizate în bara de

adrese a browserului, ele urmând după URL-ul fişierului ce conţine scriptul care le va

prelucra. Datele introduse de utilizator vor fi sub forma de perechi nume=valoare. Caracterul

? semnifică faptul că se transmit date către server, iar perechile nume=valoare pot fi

separate prin caracterul &. De exemplu pentru a cauta informaţii referitoare la ASP.NET în

Live Search, se poate folosi url-ul: http://search.live.com/results.aspx?q=ASP.NET.

Metoda POST permite ca transmiterea datelor către server să se facă în flux,

putându-se transmite cantităţi mari de date. De asemenea, datele trimise nu mai sunt afişate

în bara de adrese a browserului, lucru util când se transmit informaţii confidenţiale.

La nivelul serverului, datele primite de la browser (via HTTP) sunt prelucrate de un

script, o aplicatie sau chiar un framework:

• CGI (Common Gateway Interface). Reprezinta o serie de script-uri executate

pe serverul web. Acestea pot fi scrise in orice limbaj de programare (interpretat sau compilat)

cu respectarea urmatoarelor restrictii: programul scrie datele la iesirea standard si genereaza

antete care permit serverului Web să interpreteze corect iesirea scriptului, conform

specificatiilor HTTP.

• PHP (iniţial Personal Home Page apoi PHP: Hypertext Preprocessor) şi ASP

(Active Server Pages). ASP (Active Server Pages) este o platformă de programare Web

creată de Miscrosoft. Lucrează bine cu serverul IIS, dar există versiuni şi pentru alte servere

Web. Desi difera din punct de vedere al sintaxei, atat PHP cat si ASP sunt interpretate,

codul lor fiind stocat in fisiere externe cu extensia .php/.asp. De fapt, ASP nu ofera un limbaj

nou, ci se bazeaza pe limbajele VBScript si JScript. Un fisier PHP/ASP poate fi combinat cu

date de tip text, marcatori HTML si comenzi script. in momentul executiei, in urma cererii

unui client Web, fisierul este procesat, fiecare script din cadrul lui este interpretat si rezultatul

executiei este introdus inapoi in fisierul static HTML inainte ca rezultatul să fie trimis catre

client (browser web). Aceste modele completeaza destul de bine suportul dezvoltarii

aplicatiilor Web, insa aduc unele limitari: sunt lente deoarece la fiecare accesare fisierele

sunt procesate si interpretate (in loc să fie compilate), nu sunt capabile să construiasca

controale reutilizabile care să incapsuleze functionalitati complexe pentru interactiunea cu

utilizatorul • Perl (Practical Extraction and Report Language) este un limbaj de programare

complex, precursor al PHP

• JSP (JavaServer Pages) este o platformă de programare Web creată de Sun

Microsystems şi face parte din specificaţia Java 2 Entreprise Edition (J2EE).

Protocoale de reţea 61

JSP utilizează sintaxa XML şi o serie de clase şi funcţii Java. Codul JSP este

compilat de servlet-uri binare pentru o procesare rapidă.

Server-side scripting reprezintă „programarea” comportamentului serverului, iar client-side

scripting se refera la „programarea” comportamentului browserului de pe client. Programarea

la nivel de client se realizează în special prin JavaScript.

62 Programare Web (suport de curs)

3. Programarea client - side

Unul din primele elemente fundamentale ale WWW ( World Wide Web ) este HTML

(Hypertext Markup Language), care descrie formatul primar in care documentele sint

distribuite si vazute pe Web. Multe din trasaturile lui, cum ar fi independenta fata de

platforma, structurarea formatarii si legaturile hipertext, fac din el un foarte bun format pentru

documentele Internet si Web.

Standardul oficial HTML este stabilit de World Wide Web Consortium (W3C), care este

afiliat la Internet Engineering Task Force (IETF). W3C a enuntat cateva versiuni ale

specificatiei HTML, printre care si HTML 2.0, HTML 3.0,HTML 3.2, HTML 4.0 si, cel mai

recent, HTML 4.01. In acelasi timp, autorii de browsere, cum ar fi Netscape si Microsoft, au

dezvoltat adesea propriile "extensii" HTML in afara procesului standard si le-au incorporat in

browserele lor. In unele cazuri, cum ar fi tagul Netscape , aceste extensii au devenit

standarde de facto adoptate de autorii de browsere.

3.1. Elemente avansate de HTML

3.1.1. Tabele

Tabelele ne permit să cream o retea dreptunghiulara de domenii, fiecare domeniu

avand propriile optiuni pentru culoarea fondului, culoarea textului, alinierea textului etc.

Pentru a insera un tabel se folosesc etichetele corespondente <table>...</table>. Un tabel

este format din randuri. Pentru a insera un rand într-un tabel se folosesc etichetele

<tr>...</tr> ("table row "= rand de tabel ).

Un rand este format din mai multe celule ce contin date. O celula de date se

introduce cu eticheta <td>..</td>.

<html>

<head>

<title>tabel</title>

</head>

<body>

<h1 align=center>Un tabel simplu format din 4 linii si 2 coloane</h1>

<hr>

<table>

<tr>

</tr>

<tr>

</tr>

<tr>

</tr>

<tr>

</tr>

</table>

</body>

</html>

Programarea client - side 63

In mod prestabilit, un tabel nu are chenar. Pentru a adauga un chenar unui tabel, se

utilizeaza un atribut al etichetei <tabel> numit border. Acest atribut poate primi ca valoare

orice numar intreg ( inclusiv 0 ) si reprezinta grosimea in pixeli a chenarului tabelului. Daca

atributul border nu este urmata de o valoare atunci tabelul va avea o grosime prestabilita

egala cu 1 pixel, o valoare egala cu 0 a grosimii semnifica absenta chenarului. Cand atributul

border are o valoare nenula chenarul unui tabel are un aspect tridimensional.

<tr>

</tr>

</table>

Pentru a alinia un tabel într-o pagina Web se utilizeaza atributul align al etichetei

<table>, cu urmatoarele valori posibile: " left " ( valoarea prestabilita ), " center " si "right ".

Alinierea este importanta pentru textul ce inconjoara tabelul. Astfel :

• daca tabelul este aliniat stanga ( <table align="left"> ), atunci textul care

urmeaza dupa punctul de inserare al tabelului va fi dispus in partea dreapta a

tabelului.

• daca tabelul este aliniat dreapta ( <table align="right"> ), atunci textul care

urmeaza dupa punctul de inserare al tabelului va fi dispus in partea stanga a

tabelului.

• daca tabelul este aliniat pe centru ( <table align="center"> ), atunci textul care

urmeaza dupa punctul de inserare al tabelului va fi afisat pe toata latimea

paginii, imediat sub tabel.

Culoarea de fond se stabileste cu ajutorul atributului bgcolor, care poate fi atasat

intregului tabel prin eticheta <table>, unei linii prin eticheta <tr> sau celule de date prin

eticheta <td>. Valorile pe care le poate primi bgcolor sunt cele cunoscute pentru o culoare.

Daca in tabel sunt definite mai multe atribute bgcolor, atunci prioritatea este urmatoarea:

<td>, <tr>, <table> ( cu prioritate cea mai mica ).

<html>

<head>

<title>tabel</title>

</head>

<body>

<h1 align=center>Un tabel simplu colorat</h1>

<hr>

<tr>

<td>verde 11</td>

</tr>

<td>albastru 21</td>

<td bgcolor="yellow">galben 22</td>

</tr>

</tr>

<tr>

</tr>

</table>

64 Programare Web (suport de curs)

</body>

</html>

Culoarea textului din fiecare celula se pote stabili cu ajutorul expresiei:

<font color="valoare">...</font>.

Distanta dintre doua celule vecine se defineste cu ajutorul atributului cellspacing al

etichetei <table>.Valorile acestui atribut pot fi numere intregi pozitive, inclusiv 0, si reprezinta

distanta in pixeli dintre doua celule vecine. Valorea prestabilita a atributului cellspacing este

2. Distanta dintre marginea unei celule si continutul ei poate fi definita cu ajutorul

atributului cellpadding al etichetei <table>.Valorile acestui atribut pot fi numere intregi

pozitive, si reprezinta distanta in pixeli dintre celule si continutul ei. Valorea prestabilita a

atributului cellpadding este 1.

Dimensiunile unui tabel - latimea si inaltimea - pot fi stabilite exact prin intermediul a

doua atribute, width si height, ale etichetei <table>.Valorile acestor atribute pot fi:

• numere intregi pozitive reprezentand latimea respectiv inaltimea in pixeli a

tabelului;

• numere intregi intre 1 si 100, urmate de semnul %, reprezentand fractiunea

din latimea si inaltimea totala a paginii.

<html>

<head>

<title>tabel</title>

</head>

<body>

<tr>

<h2>Text centrat.</h2>

</td>

</tr>

</table>

</body>

</html>

Un tabel poate avea celule cu semnificatia de cap de tabel. Aceste celule sunt

introduse de eticheta <th> ( de la " tabel header " = cap de tabel ) in loc de <td>. Toate

atribute care pot fi atasate etichetei <td> pot fi de asemenea atasate etichetei <th>.

Continutul celulelor definite cu <th> este scris cu caractere aldine si centrat.

Alinierea pe orizontala a continutului unei celule se face cu ajutorul atributului align

care poate lua valorile:

• left ( la stanga );

• center ( centrat , valoarea prestabilita );

• right ( la dreapta );

• char ( alinierea se face fata de un caracter ).

Alinierea pe verticala a continutului unei celule se face cu ajutorul atributului valign

care poate lua valorile:

• baseline ( la baza );

• bottom ( jos );

• middle ( la mijloc, valoarea prestabilita );

• top ( sus ).

Aceste atribute pot fi atasate atat etichetei <tr> pentru a defini tuturor elementelor

celulelor unui rand, cat si etichetelor <td> si <th> pentru a stabili alinierea textului într-o

singura celula.

Programarea client - side 65

Un tabel trebuie privit ca o retea dreptunghiulara de celule.Cu ajutorul a doua atribute

ale etichetelor <td> si <th>, o celula se poate extinde peste celule vecine.

Astfel:

• extinderea unei celule peste celulele din dreapta ei se face cu ajutorul

atributului colspan, a carui valoare determina numarul de celule care se

unifica.

• extinderea unei celule peste celulele dedesubt se face cu ajutorul atributului

rowspan, a carui valoare determina numarul de celule care se unifica.

Sunt posibile extinderi simultane ale unei celule pe orizontala si pe verticala. In acest

caz , in etichetele <td> si <th> vor fi prezente ambele atribute colspan si rowspan.

<html>

<head>

<title>table</title>

</head>

<body>

<h1 align=center>Un tabel simplu cu chenar</h1>

<hr>

<tr>

</tr>

<tr>

</tr>

<tr>

</tr>

<tr>

</tr>

</table>

</body>

</html>

Daca un tabel are celule vide, atunci aceste celule vor aparea in tabel fara un chenar

de delimitare.

In scopul de a afisa un chenar pentru celule vide se utilizeaza &nbsp în interiorul unei

celule: • dupa <td> se pune  ;

• dupa <td> se pune <br>.

Caracterul   ( no breakable space ) este de fapt caracterul spatiu.Un spatiu

introdus prin intermediul acestui caracter nu va fi ignorat de browser.

3.1.2. Frames (cadre) în HTML

Ferestrele sau (cadrele) ne permit să definim in fereastra browserului subferestre in

care să fie incarcate documente HTML diferite.Ferestrele sunt definite într-un fisier HTML

special , in care blocul <body>...</body> este inlocuit de blocul <frameset>...</frameset>. In

interiorul acestui bloc, fiecare cadru este introdus prin eticheta <frame>.

66 Programare Web (suport de curs)

Un atribut obligatoriu al etichetei <frame> este src, care primeste ca valoare adresa

URL a documentului HTML care va fi incarcat in acel frame. Definirea cadrelor se face prin

impartirea ferstrelor (si a subferestrelor) in linii si coloane:

• impartirea unei ferstre într-un numar de subferestre de tip coloana se face cu

ajutorul atributului cols al etichetei <frameset> ce descrie acea fereastra;

• impartirae unei ferestre într-un numar de subferestre de tip linie se face cu

ajutorul atributului rows al etichetei <frameset> ce descrie acea fereastra;

• valoare atributelor cols si rows este o lista de elmente separate prin virgula ,

care descriu modul in care se face impartirea.

Elementele listei pot fi:

• un numar intreg de pixeli;

• procente din dimensiunea ferestrei (numar intre 1 si 99 terminat cu %);

• n* care inseamna n parti din spatiul ramas;

Exemplu 1: cols=200,*,50%,* inseamna o impartire in 4 subferestre, dintre care prima are

200 pixeli, a treia ocupa jumatate din spatiul total disponibil , iar a doua si a patra ocupa in

mod egal restul de spatiu ramas disponibil.

Exemplu 2: cols=200,1*,50%,2* inseamna o impartire in 4 subferestre , dintre care prima

are 200 pixeli , a treia ocupa jumatate din spatiul total disponibil iar a doua si a patra ocupa

in mod egal restul de spatiu ramas disponibil, care se imparte in trei parti egale , a doua

fereastra ocupand o parte , iar a patra ocupand 2 parti.

Observatii: • daca mai multe elemente din lista sunt configurate cu * , atunci spatiul

disponibil ramas pentru ele se va imparti in mod egal.

• o subfereastra poate fi un cadru (folosind <frame>)in care se va incarca un

document HTML sau poate fi impartita la randul ei la alte subfereste (folosind

<frameset>).

<html>

<head>

<title>frames</title>

</head>

</frameset>

</html>

In exemplul urmator este creata o pagina Web cu trei cadre mixte.Pentru a o crea se

procedeaza din aproape in aproape. Mai intai, pagina este impartita in doua subferestre de

tip coloana, dupa care a doua subfereastra este impartita in doua subferestre de tip linie.

<html>

<head>

<title>frames</title>

</head>

</frameset>

</html>

Pentru a stabili culoarea chenarului unui cadru se utilizeaza atributul bordercolor.

Acest atribut primeste ca valoare un nume de culoare sau o culoare definita in conformitate

Programarea client - side 67

cu modelul de culoare RGB.Atributul bordercolor poate fi atasat atat etichetei <frameset>

pentru a stabili culoarea tuturor chenarelor cadrelor incluse,cat si etichetei <frame> pentru a

stabili culoarea chenarului pentru un cadru individual.

Atributul border al etichetei <frameset> permite configurarea latimii chenarelor tuturor

cadrelor la un numar dorit de pixeli. Valoarea prestabilita a atributului border este de 5 pixeli.

O valoare de 0 pixeli va defini un cadru fara chenar.

<html>

<head><title>frames</title></head>

</frameset>

</html>

Pentru a obtine cadre fara chenar se utilizeaza border="0". In mod prestabilit,

chenarul unui cadru este afisat si are aspect tridimensional. Afisarea chenarului unui cadru

se poate dezactivata daca se utilizeaza atributul frameborder cu valoare "no". Acest atribut

poate fi atasat atat etichetei <frameset> (dezactivarea fiind valabila pentru toate cadrele

incluse) cat si etichetei <frame> (dezactivarea fiind valabila numai pentru un singur cadru).

Valorile posibile ale atributului frameborder sunt: "yes" -echivalent cu 1; "no" -

echivalent cu 0;

<html>

<head><title>frames</title></head>

</frameset>

</html>

Atributul scrolling al etichetei <frame> este utilizat pentru a adauga unui cadru o bara

de derulare care permite navigarea in interiorul documentului afisat in interiorul cadrului.

Valorile posibile sunt:

• yes - barele de derulare sunt adaugate intotdeauna;

• no - barele de derulare nu sunt utilizabile;

• auto - barele de derulare sunt vizibile atunci cand este necesar

<html>

<head><title>frames</title></head>

</frameset>

</html>

Atributul noresize al etichetei <frame> (fara nici o valoare suplimentara) daca este

prezent, inhiba posibilitatea prestabilita a utilizatorului de a redimensiona cadrul cu ajutorul

mouse-ului.

Un cadru intern este specificat prin intermediul blocului <iframe>...</iframe>. Un

cadru intern se insereaza într-o pagina Web in mod asemanator cu o imagine sau in modul

in care se specifica marcajul <frame>, asa cum rezulta din urmatorul exemplu: <iframe

src="iframes_ex.html" height=40% width=50%> </iframe>

In acest caz fereastra de cadru intern care are 40%din inaltimea si 50% din latimea

paginii curente.

68 Programare Web (suport de curs)

Atributele aceptate de eticheta <iframe> sunt in parte preluate de la etichetele

<frame> si <frameset>, cum ar

fi:src,border,frameborder,bordercolor,marginheight,marginwidth,scrolling,name,noresize; sau

de la eticheta <img> vspace,hspace,align,width,height;

In mod prestabilit, la efectuarea unui clic pe o legatura noua pagina (catre care indica

legatura) o inlocuieste pe cea curenta in aceeasi fereastra (acelasi cadru). Acest

comportament se poate schimba in doua moduri:

• prin plasarea in blocul <head>...</head> a unui element <base> care

precizeaza,prin atributul target numele ferestrei (cadrului) in care se vor

incarca toate paginile noi referite de legaturile din pagina curenta conform

sintaxei: <base target="nume_ferastra/frame_de_baza">

• prin plasarea in eticheta <a> a atributului target, care precizeaza numele

ferestrei (cadrului) in care se va incarca pagina nou referita de legatura,

conform sintaxei: <a href="legatura" target="nume_fereastra/frame">...</a>

Daca este prezent atat un atribut target in <base> cat si un atribut target in <a>,

atunci cele precizate de atributul target din <a> sunt prioritare.

Numele unui cadru este stabilit prin atributul name al etichetei <frame> conform

sintaxei: <farme name="nume_frame">

In exemplul urmator este prezentata o pagina Web cu doua cadre. Toate legaturile

din cadrul 1 incarca paginile in cadrul 2.

<html>

<head><title>frames</title></head>

</frameset>

</html>

<html>

<head><title>frame_left</title> </head>

<body>

Fisierul1</a><br> <a href="p2.html" target="main">

Fisierul2</a><br> <a href="p3.html" target="main">

Fisierul3</a><br><br> <a href="p1.html" target="_blank">

Fis1 într-o fereastra noua</a><br><br> <a href="p1.html" target="_self">

Fis1 in fereastra curenta</a><br><br> <a href="p.html" target="main">

Home</a><br>

</body>

</html>

Atributul target al etichetei<frame> accepta anumite valori :

• "_self" (incarcarea noii pagini are loc in cadrul curent);

• "_blank" (incarcarea noii pagini are loc într-o fereastra noua anonima);

• "_parent" (incarcarea noii pagini are loc in cadrul parinte al cadrului curent

daca acesta exista, altfel are loc in fereastra browserului curent);

• "_top" (incarcarea noii pagini are loc in fereastra browserului ce contine cadrul

curent);

3.1.3. Formulare

Un formular este un ansamblu de zone active alcatuit din butoane, casete de

selectie, campuri de editare etc. Formularele asigura construirea unor pagini Web care

permit utilizatorilor să introduca informatii si să le transmita serverului. Formularele pot varia

de la o simpla caseta de text , pentru introducerea unui sir de caractere pe post de cheie de

Programarea client - side 69

cautare, pana la o structura complexa, cu multiple sectiuni, care ofera facilitati puternice de

transmisie a datelor.

Un formular este definit într-un bloc delimitat de etichetele corespondente

<form> si </form>.

Exista doua atribute importante ale elementului <form>.

1. Atributul action precizeaza ce se va intampla cu datele formularului odata ce

acestea ajung la destinatie. De regula , valoarea atributului action este adresa URL a unui

script aflat pe un server WWW care primeste datele formularului , efectueaza o prelucrare a

lor si expedieaza catre utilizator un raspuns.

<form action="http://www.yahoo.com/cgi-bin/nume_fis.cgi">.

Script-urile pot fi scrise in limbajele Perl, C, PHP, Unix shell. etc

2. Atributul method precizeaza metoda utilizata de browser pentru expedierea datelor

formularului. Sunt posibile urmatoarele valori:

• get (valoarea implicita). In acest caz , datele din formular sunt adaugate la adresa

URL precizata de atributul action; (nu sunt permise cantitati mari de date - maxim 1

Kb )

• post In acest caz datele sunt expediate separat. Sunt permise cantitati mari de date

(ordinul MB)

Majoritatea elementelor unui formular sunt definite cu ajutorul etichetei <input>.

Pentru a preciza tipul elementului se foloseste atributul type al etichetei <input>. Pentru un

camp de editare, acest atribut primeste valoarea "text". Alte atribute pentru un element

<input> sunt:

• atributul name ,permite atasarea unui nume fiecarui element al formularului.

• atributul value ,care permite atribuirea unei valori initiale unui element al

formularului.

Un buton de expediere al unui formular se introduce cu ajutorul etichetei <input>, in

care atributul type este configurat la valoarea "submit".Acest element poate primi un nume

prin atributul name. Pe buton apare scris "Submit Query" sau valoarea atributului value, daca

aceasta valoare a fost stabilita.

First:<input type="text" name="First" size="12 maxlength="12" />

Last:<input type="text" name="Last" size="24" maxlength="24" />

</form>

Pentru elementul <input> de tipul camp de editare (type = "text") , alte doua atribute

pot fi utile: • atributul size specifica latimea campului de editare depaseste aceasta latime,

atunci se executa automat o derulare acestui camp;

• atributul maxlength specifica numarul maxim de caractere pe care le poate

primi un camp de editare; caracterele tastate peste numarul maxim sunt

ignorate.

Daca se utilizeaza eticheta <input> avand atributul type configurat la valoarea

"password" , atunci in formular se introduce un element asemanator cu un camp de

editare obisnuit (introdus prin type="text"). Toate atributele unui camp de editare

raman valabile. Singura deosebire consta in faptul ca acest camp de editare nu

afiseaza caracterele in clar, ci numai caractere *, care ascund de privirile altui

utilizator aflat in apropiere valoarea introdusa într-un asemenea camp. La expedierea

formularului insa, valoarea tastata într-un camp de tip "password" se transmite in

clar.

70 Programare Web (suport de curs)

<html>

<head><title>forms</title></head>

<body><h1>Un formular cu un buton reset</h1>

<hr>

Nume:<input type="text" name="nume" value="Numele"><br>

Prenume:<input type="text" name="prenume" value="Prenumele"><br>

Password:<input type="password" name="parola" ><br>

</html>

Butoanele radio permit alegerea , la un moment dat , a unei singure variante

din mai multe posibile. Butoanele radio se introduc prin eticheta <input> cu atributul

type avand valoarea "radio".

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

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

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

O caseta de validare (checkbox) permite selectarea sau deselectarea unei

optiuni. Pentru inserarea unei casete de validare se utilizeaza eticheta <input> cu

atributul type configurat la valoarea "checkbox".

Fiecare caseta poate avea un nume definit prin atributul name.fiecare caseta poate

avea valoarea prestabilita "selectat" definita prin atributul checked.

<p>Please select every sport that you play.</p>

Soccer: <input type="checkbox" checked="yes" name="sports" value="soccer" />

<br />

Football: <input type="checkbox" name="sports" value="football" />

<br />

Baseball: <input type="checkbox" name="sports" value="baseball" />

<br />

Basketball: <input type="checkbox" checked="yes" name="sports" value="basketball"

Intr-o pereche "name = value" a unui formular se poate folosi intregul continut

al unui fisier pe post de valoare. Pentru aceasta se insereaza un element <input>

într-un formular , cu atributul type avand valoarea "file" (fisier). Atributele pentru un

element de tip caseta de fisiere:

• atributul name permite atasarea unui nume

• atributul value primeste ca valoare adresa URL a fisierului care va fi expediat o

data cu formularul. Aceasta valoare poate fi atribuita direct atributului value, se

poate fi tastata într-un camp de editare ce apare o data cu formularul sau poate fi

selectata prin intermediul unei casete de tip File Upload sau Choose File care

apare la apasarea butonului Browse... din formular;

• atributul enctype precizeaza metoda utilizata la criptarea fisierului de

expediat.Valoarea acestui atribut este "multipart/form-data".

O lista de selectie permite utilizatorului să aleaga unul sau mai multe elemente

dîntr-o lista finita. Lista de selectie este inclusa in formular cu ajutorul etichetelor

corespondente <select>si </select>.

O lista de selectie poate avea urmatoarele atribute:

Programarea client - side 71

• atributul name, care ataseaza listei un nume (utilizat in perechile "name=value"

expediat serverului);

• atributul size, care precizeaza (prîntr-un numar intreg pozitiv , valoarea

prestabilita fiind 1) cate elemente din lista sunt vizibile la un moment dat pe ecran

(celelalte devenind vizibile prin actionarea barei de derulare atasate automat

listei).

Elementele unei liste de selectie sunt incluse in lista cu ajutorul etichetei

<option>.

Doua atribute ale etichetei option se dovedesc utile:

• atributul value primeste ca valore un text care va fi expediat serverului in

perechea "name=value"; daca acest atribut lipseste , atunci catre server va fi

expediat textul ce urmeaza dupa <option>;

• atributul selected (fara alte valori) permite selectarea prestabilita a unui elemment

al listei.

<option>Bucuresti -- B</option>

<option>Craiova -- DJ</option>

</select>

O lista de selectie ce permite selectii multiple se creeaza intocmai ca o lista de

selectie obisnuita. In plus, eticheta <select> are un atribut multiple (fara alte valori).

Cand formularul este expediat catre server pentru fiecare element selectat al listei

care este se insereaza cate o pereche "name=value" unde name este numele listei.

<option>Bucuresti -- B</option>

<option>Craiova -- DJ</option>

</select>

Intr-un formular campuri de editare multilinie pot fi incluse cu ajutorul etichetei

<textarea>. Eticheta are urmatoarele atribute:

• atributul cols, care specifica numarul de caractere afisate într-o linie;

• atributul rows, care specifica numarul de linii afisate simultan;

• atributul name, care permite atasarea unui nume campului de editare multilinie;

• atributul wrap, (de la "word wrap"=trecerea cuvintelor pe randul urmator0, care

determina comportamentul campului de editare fata de sfarsitul de linie.

Acest atribut poate primi urmatoarele valori:

a) " off "; in acest caz:

• intreruperea cuvintelor la marginea dreapta a editorului se produce numai cand

doreste utilizatorul;

• caracterul de sfarsit de linie este inclus in textul transmis serverului o data cu

formularul;

b) " hard "; in acest caz:

• se produce intreruperea cuvintelor la marginea dreapta a editorului ;

• caracterul de sfarsit de linie este inclus in textul transmis serverului o data cu

formularul;

c) " soft "; in acest caz:

• se produce intreruperea cuvintelor la marginea dreapta a editorului ;

• nu se include caracterul de sfarsit de linie in textul transmis serverului o data cu

formularul;

72 Programare Web (suport de curs)

As you can see many times word wrapping is often the desired look for your textareas.

Since it makes everything nice and easy to read.

</textarea>

As you can see many times word wrapping is often the desired look for your text areas.

Since it makes everything nice and easy to read.

</textarea>

Intr-un formular pot fi afisate butoane.Cand utilizatorul apasa un buton, se lanseaza in

executie o functie de tratare a acestui eveniment. Limbajul HTML nu permite scrierea unor

astfel de functii (acest lucru este posibil daca se utilizeaza limbajele Javascript sau Java).

Pentru a insera un buton într-un formular, se utilizeaza eticheta <input> avand atributul type

configurat la valoarea "button".Alte doua atribute ale elementului "button" sunt:

• atributul name, care permite atasarea unui nume butonului

• atributul value, care primeste ca valoare textul ce va fi afisat pe buton.

Toate elementele cuprinse într-un formular pot avea un atribut disabled care permite

dezactivarea respectivului element si un atribut readonly care interzice modificarea

continutului acestor elemente.

3.2. XML

Xml (eXtensible Markup Language) este un limbaj care permite definirea

documentelor ce contin informatii într-un mod structurat. Informatia structurata dintr-un

document xml are atat continut (cuvinte, imagini, etc.), cat si o indicatie despre rolul pe care il

are acel continut (de exemplu continutul din sectiunea header are alt rol fata de cel din

footer, care la randul lui e diferit de continutul dintr-un tabel al unei baze de date). Toate

documentele au o anumita structura. Aceste structuri se construiesc utilizand marcatori.

W3.org se ocupa de standardizarea XML-ului, si specificatiile complete ale acestui limbaj se

afla la adresa http://www.w3.org/TR/WD-xml .

In HTML, atat multimea de tag-uri (marcatori), cat si semantica asociata fiecarui tag

sunt predefinite. Spre exemplu <H1> va reprezenta intotdeauna un header de nivel 1, iar tag-

ul <documentHTML> nu are nici un sens (nu are asociata nici o valoare semantica).

Standardul XML nu specifica nici semantica si nici multimea de tag-uri ale limbajului. De fapt

XML este un metalimbaj pentru definirea limbajelor bazate pe marcatori (markup language).

Cu alte cuvinte XML permite definirea de tag-uri precum si relatia dintre acestea. Deoarece

nu exista o multime de tag-uri predefinita, nu exista nici o semantica asociata cu acestea.

Definirea semantica documentelor XML este o sarcina a aplicatiilor care folosesc

documentelor respective sau a foilor de stiluri

Avantaje XML:

• XML descrie continutul si modul de afisare al continutului;

• informatia este mai usor de gasit si manipulat daca este in format XML;

• XML ofera facilitati multiple si imbunatatite de prezentare (de exemplu folosind

browserele)

Structura unui document XML este arborescentă:

<book>

<title>My First XML</title>

<chapter>Introduction to XML

</chapter>

<chapter>XML Syntax

<para>Elements must have a closing tag</para>

<para>Elements must be properly nested</para>

</chapter>

</book>

Programarea client - side 73

<book> este elementul rădăcină (root), title, prod şi chapter sunt fraţi (siblings) şi sunt copii

(child) lui book.

3.3. CSS - Cascading Style Sheets (foi de stil in cascada)

Stilurile pun la dispozitia creatorilor de site-uri noi posibilitati de personalizare

a paginilor Web. Un stil reprezinta un mod de a scrie un bloc de text ( adica anumite

valori pentru font, marime culoare, aliniere, distante fata de margini etc). Exista doua

modalitati de a defini un stil:

• sintaxa CSS (Cascading Style Sheets);

• sintaxa Javascript.

O foaie este construită din reguli de stil care spun unui browser cum să arate

un document. Regulile de stil sunt formate după cum urmează: selector { property:

value }

Declaraţiile de stil multiple pentru un singur selector pot fi despărţite de punct

şi virgulă:

selector { property1: value1; property2: value2 }

Ca exemplu, următorul segment de cod defineşte proprietăţile culoare (color)

şi mărime-font (font-size) pentru elementele H1 şi H2:

<head>

<title>exemplu css</title>

<style>

h1 { font-size: x-large; color: red }

h2 { font-size: large; color: blue }

</style>

</head>

Orice element HTML este un posibil selector CSS1. Selectorul este elementul

care este legatla un stil particular. De exemplu, selectorul în declaraţia CSS: P { text-

indent: 3em }, este P.

Declaraţiile CSS pot fi introduse într-o pagina HTML în 3 moduri: inline, intern

şi extern.

1) Declaraţia inline se realizeză cu ajutorul tag-ului style. De exemplu:

<p style="background: blue; color: white;">A new background and font color

with inline CSS</p>

La modul general declaraţia este de forma:

O eroare des întâlnită este folosirea „” în interiorul declaraţ