CYAN GALBEN NEGRU

MAGENTA PANTONE 123 C

CĂRȚI PENTRU PROFESIONIȘTI DE CĂTRE PROFESIONIȘTI® VOCEA® EXPERTULUI ÎN .NET

Companion
eBook

Începând cu ASP.NET 4 în C# 2010 disponibil

Început
Dragă cititorule,

ASP.NET 4 în C# 2010
Bine ați venit la cea mai actualizată și cuprinzătoare carte ASP NET de început
pe care o veți găsi pe orice raft. După cum probabil știți deja, ASP.NET este un
cadru pentru dezvoltarea aplicațiilor web moderne. În mâinile potrivite, ASP.NET
produce aplicații web sigure, extrem de rapide și extrem de scalabile. Cel mai

Început
bun dintre toate, ASP.NET include un set imens de funcții gata de utilizare, cum
Matthew MacDonald, ar fi navigarea site-ului web, legarea datelor, temele și gestionarea utilizatorilor.
autorul cărții ASP.NET vă permite să creați totul, de la un site web personal dinamic la o
vitrină de comerț electronic la scară largă.

ASP.NET 4
Pro ASP.NET 4 în
În această carte, presupun că aveți doar cunoștințe de bază despre C #, deși cei
C# 2010 Pro
care provin dintr-un mediu mai experimentat vor găsi că elementele de bază sunt
Silverlight 4 în C#
revizuite rapid și eficient. Pe măsură ce explorați ASP.NET, veți învăța baza de
Pro WPF în C# 2010 date cheie, principiile de securitate și performanță pe care trebuie să le
ASP.NET: referința cunoașteți pentru a proiecta o aplicație web solidă. Cartea mea vă va învăța, de
completă asemenea, să utilizați tehnici precum programarea orientată pe obiecte și
dezvoltarea codului din spatele dezvoltării de la început, mai degrabă decât să o

în C# 2010
falsificați cu tehnici simplificate care nu vor funcționa bine în viața reală.
Odată ce ați ajuns la sfârșitul cărții, veți stăpâni tehnicile de bază ale programării
site-urilor web și veți avea cunoștințele necesare pentru a începe să lucrați ca
dezvoltator profesionist de ASP.NET.

Bine ați venit la bord!

Matthew MacDonald (MVP Microsoft, MCSD)

FOAIA DE PARCURS APRESS

Carte electronică însoțitoare Pro Pentru ASP.NET Începeți-vă călătoria cu elementele

ASP.NET 4 în C# 2010
cadru MVC 2
Început
fundamentale ale construirii site-urilor web
ASP.NET 4 în C#
Pro C# 2010
ASP.NET
2010 Pro
și platforma ASP.NET 4
Vedeți ultima pagină .NET 4 CMS
pentru detalii despre
versiunea cărții
electronice de 10

Marius
USD

CODUL SURSĂ ONLINE

www.apress.com ISBN 978-1-4302-2608-6
Matei MacDonald
54999
US 49.99 dolari

Raft în: Limbaje de

programare / C#

Nivel utilizator:
9781430226086
Început–Intermediar

Această imprimare numai pentru conținut - dimensiunea și culoarea nu sunt exacte cotor = 1.90625" Număr de pagini 1016
 Începând cu ASP.NET 4 în
C# 2010

•■■
Matei MacDonald
Începând cu ASP.NET în C# 2010
Copyright © 2010 de Matthew MacDonald
Toate drepturile rezervate. Nicio parte a acestei lucrări nu poate fi reprodusă sau transmisă sub nicio formă sau
prin orice mijloace, electronice sau mecanice, inclusiv fotocopiere, înregistrare sau prin orice sistem de stocare
sau recuperare a informațiilor, fără permisiunea prealabilă scrisă a editorului drepturilor de autor.
ISBN-13 (PBK): 978-1-4302-2608-6
ISBN-13 (electronic): 978-1-4302-2609-3
Tipărit și legat în Statele Unite ale Americii 9 8 7 6 5 4 3 2 1
Numele mărcilor comerciale, siglele și imaginile pot apărea în această carte. În loc să folosim un simbol
al mărcii comerciale la fiecare apariție a unui nume de marcă comercială, a unei sigle sau a unei
imagini, folosim numele, siglele și imaginile numai într-o manieră editorială și în beneficiul proprietarului
mărcii comerciale, fără intenția de a încălca marca comercială.
Utilizarea în această publicație a denumirilor comerciale, a mărcilor comerciale, a mărcilor de servicii
și a termenilor similari, chiar dacă nu sunt identificați ca atare, nu trebuie considerată ca o exprimare
a opiniei cu privire la faptul dacă aceștia fac sau nu obiectul unor drepturi de proprietate.

Președinte și editor: Paul Manning Editor principal: Ewan Buckingham Recenzent tehnic: Damien
Foggon Colegiul de redacție: Clay Andres, Steve Anglin, Mark Beckner, Ewan Buckingham, Gary
Cornell, Jonathan Gennick, Jonathan Hassell, Michelle Lowman, Matthew Moodie, Duncan
Parkes, Jeffrey Pepper, Frank Pohlmann, Douglas Pundick, Ben Renow-Clarke, Dominic
Shakeshaft, Matt Wade, Tom Welsh Editor coordonator: Anne Collett Editor de copiere: Kim
Wimpsett Compositor: Mary Sudul Indexer: Servicii de indexare și corectură BIM Artist: April Milne
Designer de copertă: Anna Ishchenko

Distribuit în comerțul cu cărți la nivel mondial de Springer Science + Business Media, LLC., 233 Spring
Street, 6th Floor, New York, NY 10013. Telefon 1-800-SPRINGER, fax (201) 348-4505, comenzi prin
e-mail- ny@springer-sbm.com, sau vizitați www.springeronline.com.
Pentru informații despre traduceri, vă rugăm să trimiteți un e-mail rights@apress.com sau să vizitați www.apress.com.
Apress și prietenii cărților ED pot fi achiziționate în vrac pentru uz academic, corporativ sau promoțional. Versiunile
și licențele de cărți electronice sunt, de asemenea, disponibile pentru majoritatea titlurilor. Pentru mai multe
informații, consultați pagina noastră web Special Bulk Sales–eBook Licensing la www.apress.com/info/bulksales.

Informațiile din această carte sunt distribuite "ca atare", fără garanție. Deși au fost luate toate măsurile
de precauție în pregătirea acestei lucrări, nici autorul (autorii) și nici Apress nu vor avea nicio
răspundere față de orice persoană sau entitate cu privire la orice pierdere sau daună cauzată sau
presupusă a fi cauzată direct sau indirect de informațiile conținute în această lucrare.
Pentru familia mea minunată,
Faria, Maya și Brenna
 CONȚINUT

Conținut

Despre autor .................................................................................................. Xxv

Despre referentul tehnic............................................................................. XXVI
Aprecieri.............................................................................................. XXVII
Introducere....................................................................................................... XXVIII

Partea 1: Vă prezentăm ........................................................................................... .NET 1

Capitolul 1: .NET Framework .......................................................................... 3

•
Evoluția dezvoltării web................................................................................. 3
Formulare HTML și HTML .......................................................................................................................... 3
Programare pe partea de server...................................................................................................................... 6

....................................................................................................................... de programare pe partea clientului 7

.NET Framework ....................................................................................................... 9

C#, VB și limbile .NET .......................................................................................................... 11
Common Language Runtime ......................................................................................................... 13
Biblioteca de clase .NET.......................................................................................................................... 14
Studio vizual......................................................................................................................................... 15

Ultimul cuvânt................................................................................................................ 16

Capitolul 2: Limba C# .............................................................................. 17

•
Limbile .NET...................................................................................................... 17
Noțiuni de bază despre limba C# ...................................................................................................... 18
Sensibilitate la majuscule.................................................................................................................................... 18

Comentarea......................................................................................................................................... 18
Rezilierea declarației......................................................................................................................... 19

v
 CONȚINUT
•

Blocuri................................................................................................................................................... 20

Variabile și tipuri de date.............................................................................................. 20

Atribuire și inițializatoare .................................................................................................................. 22
Corzi și personaje scăpate .......................................................................................................... 24
Matrice................................................................................................................................................... 24

Enumerări ....................................................................................................................................... 26

Operațiuni variabile ....................................................................................................... 27

Matematică avansată..................................................................................................................................... 29

Tastați conversii ................................................................................................................................. 29

Manipularea bazată pe obiecte ........................................................................................... 31

Tipul de șir .................................................................................................................................... 32
Tipurile DateTime și TimeSpan..................................................................................................... 34
Tipul matricei...................................................................................................................................... 36

Logica condițională........................................................................................................... 37
Declarația IF................................................................................................................................... 38
Instrucțiunea comutatorului........................................................................................................................... 39

Bucle............................................................................................................................. 40
Pentru buclă.......................................................................................................................................... 40
Bucla foreach.................................................................................................................................. 41
Bucla while ...................................................................................................................................... 42

Metode......................................................................................................................... 43
Parametrii........................................................................................................................................... 44
Metoda de supraîncărcare ............................................................................................................................. 45

Parametri opționali și denumiți.......................................................................................................... 46

Delegaţi.............................................................................................................................................. 47

Ultimul cuvânt................................................................................................................ 48

Capitolul 3: Tipuri, obiecte și spații de nume..................................................... 49

•
Noțiuni de bază despre cursuri.............................................................................................. 49
Membrii statici .................................................................................................................................... 50
A clasă simplă...................................................................................................................................... 51

vi
 CONȚINUT

Construirea unui ................................................................................................... de clasă de bază 51

Crearea unui obiect................................................................................................................................ 53

Adăugarea proprietăților................................................................................................................................. 54

Proprietăți automate............................................................................................................................ 56
Adăugarea unei metode .................................................................................................................................. 56

Adăugarea unui constructor............................................................................................................................ 57

Adăugarea unui eveniment.................................................................................................................................... 59

Testarea clasei de produse..................................................................................................................... 60

Tipuri de valori și tipuri de referință................................................................................. 63

Operațiuni de atribuire ........................................................................................................................ 63
Testarea egalității.................................................................................................................................... 64

Trecerea parametrilor după referință și valoare.................................................................................. 64

Revizuirea tipurilor .NET.......................................................................................................................... 65

Înțelegerea spațiilor de nume și a ansamblurilor................................................................ 67

Utilizarea spațiilor de nume............................................................................................................................... 68

Importul spațiilor de nume......................................................................................................................... 69

Ansambluri........................................................................................................................................... 70

Programare avansată a clasei....................................................................................... 71

Moștenire............................................................................................................................................ 71
Membrii statici .................................................................................................................................... 73
Turnarea obiectelor..................................................................................................................................... 74

Clase parțiale...................................................................................................................................... 76
Generice................................................................................................................................................ 77

Ultimul cuvânt................................................................................................................ 79

Partea 2: Dezvoltarea ASP.NET aplicații............................................................... 81

Capitolul 4: Vizual Studio..................................................................................... 83

•
Promisiunea Visual Studio......................................................................................... 83
Crearea de site-uri web.......................................................................................................... 84
Crearea unei aplicații web goale ..................................................................................................... 85

VII
 CONȚINUT
•

Site-uri web și proiecte web.................................................................................................................. 89

Fișierele soluției ascunse..................................................................................................................... 90
Exploratorul de soluții ........................................................................................................................... 91
Adăugarea formularelor web ............................................................................................................................... 92

Migrarea unui site web de la o versiune anterioară de Visual Studio............................................................. 93

Proiectarea unei pagini web................................................................................................... 95

Adăugarea controalelor web............................................................................................................................ 96

Fereastra Proprietăți ........................................................................................................................ 98

Anatomia unui formular web ....................................................................................... 100

Marcajul formularului web....................................................................................................................... 100
Directiva privind paginile.............................................................................................................................. 101

Doctipul........................................................................................................................................ 102
Elementele esențiale ale XHTML.................................................................................................................... 104

Scrierea codului................................................................................................................ 110

Codul din spatele clasei ...................................................................................................................... 110
Adăugarea rutinelor de tratare a evenimentelor ....................................................................................................................... 110

Schiţare............................................................................................................................................. 112
IntelliSense......................................................................................................................................... 113
Formatarea și colorarea codului............................................................................................................ 117

Depanare Visual Studio.............................................................................................. 118

Visual Studio Web Server ............................................................................................................ 118
Depanare într-un singur pas....................................................................................................................... 119

Ceasuri variabile................................................................................................................................ 124

Ultimul cuvânt.............................................................................................................. 125

Capitolul 5: Fundamentele formularelor web................................................................ 127

•
Anatomia unei aplicații ASP.NET..................................................................... 127
ASP.NET tipuri de fișiere............................................................................................................................. 128

ASP.NET directoare de aplicații......................................................................................................... 129

Vă prezentăm controalele serverului......................................................................................... 130

Controale server HTML......................................................................................................................... 131

Viii
 CONȚINUT

Conversia unei pagini HTML într-o pagină ASP.NET.................................................................................. 131

Vizualizare stare .......................................................................................................................................... 134

Clasele de control HTML.................................................................................................................. 135

Adăugarea codului convertorului valutar ................................................................................................. 138
Gestionarea evenimentelor.................................................................................................................................... 140

În culise cu convertorul valutar................................................................................ 142

Tratarea erorilor..................................................................................................................................... 144

Îmbunătățirea convertorului valutar............................................................................... 144

Adăugarea mai multor valute ................................................................................................................ 145

Stocarea informațiilor în listă............................................................................................................ 146

Adăugarea imaginilor legate........................................................................................................................ 147

Setarea stilurilor ..................................................................................................................................... 150

A privire mai profundă asupra claselor de control HTML...................................................................... 151

Evenimente de control HTML .......................................................................................................................... 151

Evenimente avansate cu controlul HtmlInputImage ........................................................................... 152

Clasa de bază HtmlControl ............................................................................................................... 154
Clasa HtmlContainerControl......................................................................................................... 155
Clasa HtmlInputControl................................................................................................................ 155
Clasa de pagini ............................................................................................................ 156
Trimiterea utilizatorului la o pagină nouă........................................................................................................ 157

Codificare HTML................................................................................................................................... 158

Evenimente de aplicare....................................................................................................... 160

Fișierul global.asax............................................................................................................................ 161
Evenimente suplimentare de aplicare............................................................................................................. 162

ASP.NET Configurare ................................................................................................ 163

Fișierul web.config ............................................................................................................................ 163
Configurație imbricată.......................................................................................................................... 164
Stocarea setărilor personalizate în fișierul web.config ................................................................................. 166

Instrumentul de administrare a site-ului web (WAT) ............................................................................................. 168

Ultimul cuvânt.............................................................................................................. 170

Ix
 CONȚINUT
•

Capitolul 6: Controale web .................................................................................. 173

•
Trecerea la controalele web. ..................................................................................... 173
Clase de control web de bază . ................................................................................................................. 174

Etichetele de control web........................................................................................................................... 175

Clase de control web. .................................................................................................. 176

Clasa de bază WebControl.................................................................................................................. 177

Unităţi..................................................................................................................................................... 179

Enumerări ....................................................................................................................................... 179

Culori................................................................................................................................................... 180

Fonturi..................................................................................................................................................... 181

Focar.................................................................................................................................................... 183

Butonul implicit................................................................................................................................ 183

Controale listă. ............................................................................................................... 184

Controale listă cu selectare multiplă . .............................................................................................................. 185

Controlul BulletedList ....................................................................................................................... 187

Controale tabel. ............................................................................................................ 188

Evenimente de control web și AutoPostBack . ..................................................................... 193
Cum funcționează evenimentele postback. ................................................................................................................ 197

Ciclul de viață al paginii .............................................................................................................................. 198

A pagină web simplă. .................................................................................................... 201

Îmbunătățirea generatorului de felicitări............................................................................................... 206

Generarea automată a cardurilor .................................................................................................... 208

Ultimul cuvânt. ............................................................................................................ 211

Capitolul 7: Gestionarea, înregistrarea în jurnal și urmărirea erorilor............................................. 213

•
Erori comune. .......................................................................................................... 213
Tratarea excepțiilor. .................................................................................................... 215
Clasa de excepție ............................................................................................................................. 215

Lanțul de excepții ............................................................................................................................. 217

x
 •

Excepții de manipulare .................................................................................................... 218

Capturarea unor excepții specifice ............................................................................................................. 219

Rutine de tratare a excepțiilor imbricate................................................................................................................. 221

Tratarea excepțiilor în acțiune.............................................................................................................. 222

Stăpânirea excepțiilor......................................................................................................................... 224

Aruncându-vă propriile excepții................................................................................... 224

Excepții de înregistrare în jurnal...................................................................................................... 229

Vizualizarea jurnalelor de evenimente Windows....................................................................................................... 229

Scrierea în jurnalul de evenimente ..................................................................................................................... 232

Jurnale personalizate....................................................................................................................................... 234

A clasă de înregistrare personalizată în jurnal..................................................................................................................... 236

Recuperarea informațiilor de jurnal................................................................................................................. 237

Urmărirea paginilor................................................................................................................ 239

Activarea urmăririi................................................................................................................................. 240

Informații de urmărire............................................................................................................................ 240

Scrierea informațiilor de urmărire................................................................................................................... 246

Trasarea la nivel de aplicație................................................................................................................... 250

Ultimul cuvânt.............................................................................................................. 252

Capitolul 8: Managementul de stat ......................................................................... 253

•
Problema statului................................................................................................... 253
Vizualizare stare.................................................................................................................... 253

Colecția ViewState.................................................................................................................... 254

A exemplu de stare de vizualizare......................................................................................................................... 254

Securizarea stării de vizualizare ................................................................................................................. 255

Păstrarea variabilelor pentru membri .............................................................................................................. 257

Stocarea obiectelor personalizate...................................................................................................................... 259

Transferul informațiilor între pagini.................................................................... 260

Postarea pe mai multe pagini ............................................................................................................................ 260

Șirul de interogare................................................................................................................................. 265

 CONȚINUT
•

Modulele cookie........................................................................................................................ 269

A exemplu de cookie............................................................................................................................... 271

Starea sesiunii............................................................................................................... 272

Urmărirea sesiunii................................................................................................................................ 272

Utilizarea stării sesiunii............................................................................................................................ 273

A exemplu de stare a sesiunii.................................................................................................................... 274

Configurarea stării sesiunii ........................................................................................ 277

.......................................................................................................................................... fără cookie-uri 278

Timeout............................................................................................................................................... 281

Mod................................................................................................................................................... 281

Starea cererii.......................................................................................................... 286

O prezentare generală a opțiunilor de gestionare a statului................................................................ 288

Ultimul cuvânt.............................................................................................................. 290

Partea 3: Construirea unor formulare web mai bune....................................................................... 291

Capitolul 9: Validare ....................................................................................... 293

•
Înțelegerea validării............................................................................................. 293
controalele de validare....................................................................................................................... 294
Validare pe partea de server........................................................................................................................ 295

Validare din partea clientului......................................................................................................................... 295

Controalele de validare................................................................................................ 295

A exemplu simplu de validare.............................................................................................................. 297
Alte opțiuni de afișare......................................................................................................................... 299

Validare manuală............................................................................................................................... 302

Validarea cu expresii regulate.................................................................................................. 304

A formular de client validat................................................................................................................ 308
Grupuri de validare................................................................................................................................ 313

Ultimul cuvânt.............................................................................................................. 314

Xii
 •

Capitolul 10: Controale bogate................................................................................ 315

•
Calendarul................................................................................................................ 315
Formatarea calendarului..................................................................................................................... 317

Restricționarea datelor................................................................................................................................ 319

AdRotatorul.............................................................................................................. 323
Fișierul publicitar....................................................................................................................... 323
Clasa AdRotator ........................................................................................................................... 325

Pagini cu mai multe vizualizări........................................................................................... 326

Controlul MultiView ........................................................................................................................ 328
Controlul expertului ............................................................................................................................. 333

Ultimul cuvânt.............................................................................................................. 341

Capitolul 11: Controale utilizator și Grafică.......................................................... 343

• Controale utilizator............................................................................................................... 343
Crearea unui .......................................................................................................... simplu de control al utilizatorului 344

Controale independente ale utilizatorului................................................................................................................. 347

Controale integrate ale utilizatorului..................................................................................................................... 349

Evenimente de control al utilizatorului............................................................................................................................ 352

Transmiterea informațiilor cu evenimente........................................................................................................ 354

Grafică dinamică........................................................................................................ 357

Desen de bază .................................................................................................................................... 357
Desenarea unei imagini personalizate ................................................................................................................... 360

Plasarea imaginilor personalizate în paginile web......................................................................................... 361

Formatul imaginii și calitatea .................................................................................................................. 363

Ultimul cuvânt.............................................................................................................. 366

Capitolul 12: Stiluri, teme și pagini coordonatoare............................................... 367

•
Stiluri........................................................................................................................... 367
Tipuri de stil......................................................................................................................................... 368

Crearea unui stil de bază în linie............................................................................................................... 368

Crearea unei foi de stil........................................................................................................................ 377

 CONȚINUT
•

Aplicarea regulilor foii de stiluri................................................................................................................. 380

Teme........................................................................................................................ 383
Cum funcționează temele ............................................................................................................................. 383

Aplicarea unei teme simple................................................................................................................... 385

Gestionarea conflictelor tematice................................................................................................................... 386

Crearea mai multor fațete pentru același .................................................................................... de control 388

Skin-uri mai avansate......................................................................................................................... 389

Noțiuni de bază despre pagina coordonatoare..................................................................................................... 391

A pagină coordonatoare simplă și o pagină de conținut........................................................................................... 392

Cum sunt conectate paginile coordonatoare și paginile de conținut ...................................................................... 396

A pagină coordonatoare cu mai multe regiuni de conținut ................................................................................... 398

Conținut implicit................................................................................................................................... 401

Pagini coordonatoare și căi relative....................................................................................................... 402

Pagini coordonatoare avansate.............................................................................................. 403

Aspecte bazate pe stil........................................................................................................................... 403

Cod într-o pagină coordonatoare........................................................................................................................ 408

Interacțiunea programatică cu o pagină coordonatoare............................................................................. 409

Ultimul cuvânt.............................................................................................................. 410

Capitolul 13: Navigarea pe site....................................................................... 411

• Hărți ale site-ului..................................................................................................................... 411
Definirea unei hărți a site-ului............................................................................................................................ 412

Vedeți o hartă simplă a site-ului în acțiune.................................................................................................... 416

Legarea unei pagini obișnuite la o hartă de site............................................................................................. 416

Legarea unei pagini coordonatoare la o hartă de site ................................................................................................. 418

Legarea porțiunilor unei hărți de site........................................................................................................... 420

Clasa SiteMap.............................................................................................................................. 425

Maparea și rutarea adreselor URL ........................................................................................... 427

Maparea adreselor URL ...................................................................................................................................... 428

Rutare URL........................................................................................................................................ 428

Xiv
 •

Controlul SiteMapPath............................................................................................. 430

Particularizarea ............................................................................................................ SiteMapPath 431

Utilizarea stilurilor și șabloanelor SiteMapPath.......................................................................................... 432

Adăugarea informațiilor particularizate despre harta site-ului................................................................................................. 434

Controlul TreeView................................................................................................... 435

Proprietățile TreeView ........................................................................................................................... 436

Stiluri TreeView.................................................................................................................................. 438

Controlul meniului ........................................................................................................ 442

Stiluri de meniu........................................................................................................................................ 444

Șabloane de meniu................................................................................................................................. 445

Ultimul cuvânt.............................................................................................................. 448

Partea 4: Lucrul cu datele.................................................................................... 449

• Capitolul 14: ADO.NET

Fundamente................................................................ 451
Înțelegerea bazelor de date............................................................................................ 451
Configurarea bazei de date.......................................................................................... 453
SQL Server Express............................................................................................................................ 453

Navigarea și modificarea bazelor de date în Visual Studio ......................................................................... 454

Instrumentul de linie de comandă sqlcmd........................................................................................................ 457

Noțiuni de bază SQL................................................................................................................... 458

Rularea interogărilor în Visual Studio ....................................................................................................... 459

Instrucțiunea Selectare......................................................................................................................... 461

Instrucțiunea SQL Update................................................................................................................. 463

Instrucțiunea de inserare SQL................................................................................................................... 465

Instrucțiunea de ștergere SQL.................................................................................................................. 465

Modelul furnizorului de date ............................................................................................. 466

Acces direct la date ...................................................................................................... 467

Crearea unei conexiuni ........................................................................................................................ 469

Comanda Selectare ......................................................................................................................... 475

The DataReader.................................................................................................................................. 476

 CONȚINUT
•

Punând totul împreună......................................................................................................................... 476

Actualizarea datelor..................................................................................................................................... 481

.......................................................................................... de acces la date deconectate 491

Selectarea Date deconectate.............................................................................................................. 492

Selectarea mai multor tabele ................................................................................................................... 494

Definirea relațiilor........................................................................................................................ 495

Ultimul cuvânt.............................................................................................................. 498

• Capitolul 15: Obligativitatea datelor................................................................................. 499

Vă prezentăm Data Binding............................................................................................. 499
Tipuri de ASP.NET de legare a datelor.......................................................................................................... 500

Cum funcționează legarea datelor.................................................................................................................... 500

Legarea datelor cu valoare unică........................................................................................... 500

A exemplu simplu de legare a datelor ......................................................................................................... 501

Legarea simplă a datelor cu proprietăți.................................................................................................. 504

Probleme cu legarea datelor cu o singură valoare.......................................................................................... 505

Utilizarea codului în locul legării simple a datelor ....................................................................................... 506

Legarea datelor cu valoare repetată...................................................................................... 506

Legarea datelor cu controale simple de listă.............................................................................................. 507

A exemplu simplu de legare a listelor........................................................................................................... 508

Colecții puternic tipărite................................................................................................................. 509

Legare multiplă.................................................................................................................................. 510

Legarea datelor cu o colecție de dicționare .......................................................................................... 512

Utilizarea proprietății DataValueField..................................................................................................... 513

Legarea datelor cu ADO.NET................................................................................................................ 514

Crearea unui editor de înregistrări..................................................................................................................... 516

Controale sursă de date................................................................................................... 521

Ciclul de viață al paginii cu legare de date............................................................................................... 523

The SqlDataSource............................................................................................................................. 523

Selectarea înregistrărilor............................................................................................................................... 525

Comenzi parametrizate ................................................................................................................. 527

Xvi
 •

Erori de manipulare................................................................................................................................... 532

Actualizarea înregistrărilor............................................................................................................................... 533

Ultimul cuvânt.............................................................................................................. 537

• Capitolul 16: Controlul datelor......................................................................... 539

Vizualizarea grilă................................................................................................................ 539
Generarea automată a coloanelor .................................................................................................... 540

Definirea coloanelor ............................................................................................................................... 542

Formatarea GridView.............................................................................................. 546

Formatarea câmpurilor................................................................................................................................ 546

Utilizarea stilurilor........................................................................................................................................ 547

Valori specifice formatării ................................................................................................................ 550

Selectarea unui rând GridView............................................................................................ 552

Adăugarea unui buton Selectare....................................................................................................................... 553

Utilizarea selecției pentru a crea pagini coordonatoare................................................................................ 554

Editarea cu ............................................................................................ GridView 556

Sortarea și paginarea GridView................................................................................. 559
Sortare................................................................................................................................................ 559

Paginare................................................................................................................................................. 561

Utilizarea șabloanelor GridView........................................................................................... 563

Utilizarea mai multor șabloane................................................................................................................... 565

Editarea șabloanelor în Visual Studio..................................................................................................... 566

Gestionarea evenimentelor într-un șablon........................................................................................................... 567

Editarea cu un șablon...................................................................................................................... 568

DetailsView și FormView................................................................................... 573

DetaliiVizualizare.................................................................................................................................. 573

FormularulVizualizare..................................................................................................................................... 575

Ultimul cuvânt.............................................................................................................. 578

• Capitolul 17: Dosarele Fluxuri.........................................................................

și 579
Fișiere și aplicații web.......................................................................................... 579
 CONȚINUT
•

Informații despre sistemul de fișiere............................................................................................... 580

Clasa Path.................................................................................................................................... 581

Clasele de directoare și fișiere ........................................................................................................... 582

Clasele DirectoryInfo și FileInfo............................................................................................... 587

Clasa DriveInfo............................................................................................................................. 589
A exemplu de browser de fișiere ....................................................................................................................... 590

Citirea și scrierea cu fluxuri.............................................................................. 594

Fișiere text ............................................................................................................................................ 594

Fișiere binare......................................................................................................................................... 596

Comenzi rapide pentru citirea și scrierea fișierelor............................................................................................. 597

A simplă carte de oaspeți.......................................................................................................................... 598

Permiterea încărcării fișierelor .................................................................................................. 604

Controlul FileUpload ....................................................................................................................... 604

Ultimul cuvânt.............................................................................................................. 607

Capitolul 18: XML............................................................................................... 609

•
XML explicat............................................................................................................. 609
Îmbunătățirea listei cu XML............................................................................................................... 611
Noțiuni de bază XML......................................................................................................................................... 612

Atribute............................................................................................................................................ 613
Comentarii.......................................................................................................................................... 614

Clasele XML.......................................................................................................... 615

The XML TextWriter............................................................................................................................ 615

Cititorul de text XML.......................................................................................................................... 618

Lucrul cu documente XML în memoria ......................................................................................... 623

Citirea unui document XML ................................................................................................................ 628

Căutarea unui document XML ............................................................................................................. 631

Validare XML............................................................................................................. 632

Spații de nume XML............................................................................................................................... 632

XML Schema Definiție ...................................................................................................................... 635

Validarea unui document XML.............................................................................................................. 637

XVIII
 •

Afișare și transformare XML....................................................................................... 640

Controlul web Xml.......................................................................................................................... 642

Ultimul cuvânt.............................................................................................................. 643

Partea 5: Securitatea site-ului web....................................................................................... 645

• Capitolul 19: Fundamente de securitate................................................................. 647

Înțelegerea ............................................................................................... de securitate 647
Testarea și implementarea setărilor de securitate............................................................................................ 648

Autentificare și autorizare ................................................................................ 649

Autentificarea formularelor .................................................................................................. 649
Setări Web.config ........................................................................................................................... 651

Reguli de autorizare ............................................................................................................................ 651

WAT ............................................................................................................................................. 655

Pagina de conectare................................................................................................................................... 657

Autentificare Windows.............................................................................................. 663

Setări Web.config ........................................................................................................................... 663
Un test de autentificare Windows.......................................................................................................... 666

Ultimul cuvânt.............................................................................................................. 667

Capitolul 20: Calitatea de membru.................................................................................. 669

• Depozitul de date privind calitatea de membru........................................................................................ 669

Calitatea de membru cu SQL Server Express ............................................................................................... 671

Utilizarea versiunii complete de SQL Server.................................................................................................. 673

Configurarea furnizorului de membri................................................................................................ 676

Crearea utilizatorilor cu WAT.............................................................................................................. 679

Clasele Membership și MembershipUser ................................................................................ 682

Autentificare cu ....................................................................................................... de membru 686
Conturi dezactivate.............................................................................................................................. 687

Controalele de securitate .................................................................................................. 687

Controlul de conectare................................................................................................................................ 688

Controlul CreateUserWizard............................................................................................................ 694

 CONȚINUT
•

Controlul PasswordRecovery. .......................................................................................................... 698

Securitate bazată pe roluri . .................................................................................................. 700

Crearea și atribuirea rolurilor. ............................................................................................................. 701

Restricționarea accesului pe baza rolurilor . .................................................................................................... 705

Controlul LoginView.......................................................................................................................... 705

Ultimul cuvânt. ............................................................................................................ 707

• Capitolul 21: Profiluri ......................................................................................... 709

Înțelegerea profilurilor . .............................................................................................. 709
Performanța profilului.............................................................................................................................. 710

Cum stochează profilurile datele........................................................................................................................ 710

Utilizarea SqlProfileProvider. ...................................................................................... 712

Activarea autentificării........................................................................................................................ 712
Utilizarea SQL Server Express .................................................................................................................... 713

Utilizarea versiunii complete de SQL Server................................................................................................... 713

Bazele de date de profil........................................................................................................................... 714

Definirea proprietăților profilului.................................................................................................................... 716

Utilizarea proprietăților profilului........................................................................................................................ 717

Serializarea profilului .............................................................................................................................. 719

Grupuri de profil....................................................................................................................................... 721
Profiluri și tipuri de date particularizate. ......................................................................................................... 722

API-ul Profil ...................................................................................................................................... 725

Profiluri anonime.............................................................................................................................. 728

Ultimul cuvânt. ............................................................................................................ 731

Partea 6: ASP.NET.................................................................................... avansată 733

• Capitolul 22: Vă prezentăm ASP.NET..................................................................... 735

De ce să folosiți componente?. .............................................................................................. 735

Jargonul component . .................................................................................................... 736

Design pe trei niveluri................................................................................................................................. 736

Încapsulare....................................................................................................................................... 738

Xx
 •

Obiecte de afaceri................................................................................................................................ 738

Obiecte de date ....................................................................................................................................... 738

Componente și clase ................................................................................................................... 738

Crearea unei componente................................................................................................. 739

Clase și spații de nume................................................................................................................... 740

Membrii clasei................................................................................................................................... 742

Adăugarea unei referințe la componentă............................................................................................... 742

Utilizarea componentei ......................................................................................................................... 745

Proprietăți și stare.................................................................................................... 747

A cont statal clasa .................................................................................................................... 748
A clasă Stateless AccountUtility......................................................................................................... 749

Componente de acces la date............................................................................................ 750

A componentă simplă de acces la date..................................................................................................... 750

Utilizarea componentei de acces la date.................................................................................................... 754

Îmbunătățirea componentei cu gestionarea erorilor.................................................................................. 757

Îmbunătățirea componentei cu informații agregate..................................................................... 758

ObiectDataSource................................................................................................. 759
Făcând clase pe care ObjectDataSource le poate înțelege.................................................................... 759

Selectarea înregistrărilor............................................................................................................................... 760

Utilizarea parametrilor metodei.................................................................................................................. 761

Actualizarea înregistrărilor............................................................................................................................... 762

Ultimul cuvânt.............................................................................................................. 764

• Capitolul 23: Memorarea în cache......................................................................................... 765

Înțelegerea ............................................................................................... de memorare în cache 765
Când se utilizează memorarea în cache.......................................................................................................................... 766

Memorarea în cache în ASP.NET............................................................................................................................ 767

Memorarea în cache a ieșirilor............................................................................................................ 767

Caching pe partea clientului ................................................................................................................. 769

Memorarea în cache și șirul de interogare............................................................................................................. 769

Memorarea în cache cu parametri specifici șirului de interogare................................................................................. 770

 CONȚINUT
•

A exemplu de memorare în cache multiplă............................................................................................................... 771

Fragment Caching .............................................................................................................................. 772

Profiluri cache..................................................................................................................................... 773

Memorarea în cache a datelor ............................................................................................................... 774

Adăugarea elementelor în memoria cache ................................................................................................................. 774

A simplu test de cache........................................................................................................................... 776

Memorarea în cache pentru a oferi mai multe vizualizări ..................................................................................................... 777

Memorarea în cache cu controalele sursei de date.............................................................................................. 781

Memorarea în cache cu dependențe........................................................................................ 785

Dependențe de fișiere.............................................................................................................................. 785

Dependențele elementelor cache.................................................................................................................. 786

SQL Server Cache dependențe ....................................................................................................... 787

Ultimul cuvânt.............................................................................................................. 790

Capitolul 24: LINQ și cadrul entității.................................................... 791

•
Înțelegerea LINQ..................................................................................................... 791
Noțiuni de bază LINQ.................................................................................................................. 792

Expresii LINQ................................................................................................................................ 795

Cadrul entității.................................................................................................. 799

Crearea unui model de date de entitate............................................................................................................ 800

Diagrama modelului de date.................................................................................................................... 803

Actualizarea unui model de date....................................................................................................................... 806

Codul modelului de date ......................................................................................................................... 808

interogarea modelului de date.................................................................................................................... 809

Erori de manipulare................................................................................................................................... 810

Navigarea în relații.................................................................................................................... 812

Avansarea cu cadrul de entitate.................................................... 815

Interogarea cu LINQ către entități............................................................................................................ 815

Controlarea încărcării datelor........................................................................................................ 818

Actualizări, inserări și ștergeri............................................................................................................. 820
Gestionarea concurenței....................................................................................................................... 822

Xxii
 •

EntityDataSource .................................................................................................. 823

Afișarea datelor................................................................................................................................... 823

Editarea datelor........................................................................................................................................ 828

Ultimul cuvânt.............................................................................................................. 828

• Capitolul 25: ASP.NET AJAX............................................................................... 829

Înțelegerea lui Ajax...................................................................................................... 829
Ajax: Binele.................................................................................................................................... 830
Ajax: Cel rău...................................................................................................................................... 830
Setul de instrumente ASP.NET AJAX.................................................................................................................. 831

Managerul de scenarii............................................................................................................................. 831

Reîmprospătări parțiale ......................................................................................................... 833

Un simplu test UpdatePanel ................................................................................................................ 834

Erori de manipulare................................................................................................................................... 837

Actualizări condiționate............................................................................................................................ 839

Declanşează.............................................................................................................................................. 840

Notificare intermediară ................................................................................................... 845

Afișarea unei bare de progres simulate.................................................................................................... 845

Anulare........................................................................................................................................ 847
Reîmprospătări temporizate.......................................................................................................... 849

Setul de instrumente de control ASP.NET AJAX............................................................................... 851

Instalarea ASP.NET AJAX Control Toolkit....................................................................................... 851

Acordeonul..................................................................................................................................... 853
The AutoCompleteExtender................................................................................................................ 856
Obținerea mai multor controale......................................................................................................................... 859

Ultimul cuvânt.............................................................................................................. 864

Capitolul 26: Implementarea aplicațiilor ASP.NET .................................................. 865

•
ASP.NET aplicațiile și serverul web.................................................................. 865
Cum funcționează serverele web...................................................................................................................... 865

Directorul virtual........................................................................................................................... 867

 CONȚINUT
•

URL-uri de aplicații web......................................................................................................................... 867

Ferme web ......................................................................................................................................... 869

Internet Information Services (IIS)............................................................................... 869

Multiplele fețe ale IIS ........................................................................................................................ 869

Instalarea IIS în Windows 7 sau Windows Vista..................................................................................... 870

Instalarea IIS 7 în Windows Server 2008.............................................................................................871

Gestionarea site-uri web cu IIS Manager......................................................................... 873

Crearea unui director virtual ................................................................................................................ 874

Înțelegerea grupurilor de aplicații........................................................................................................ 876

Contul ASP.NET......................................................................................................................... 878

Configurarea unui site web ........................................................................................................................ 882

Pagina implicită ................................................................................................................................ 885

Pagini de eroare particularizate............................................................................................................................ 886

Cheia aparatului .................................................................................................. 888

Autentificare Windows..................................................................................................................... 890

Confidențialitate cu SSL și certificate ........................................................................................... 892

Implementarea unui site simplu............................................................................................... 895

Aplicații și componente web.................................................................................................... 895

Alți pași de configurare .................................................................................................................. 896
Compilarea codului ............................................................................................................................... 896

Implementarea cu Visual Studio....................................................................................... 897

Crearea unui director virtual pentru un nou proiect.................................................................................... 898

Copierea unui site web.............................................................................................................................. 901

Publicarea unui site web.......................................................................................................................... 904

Ultimul cuvânt.............................................................................................................. 905

Index..................................................................................................................... 907

Xxiv
 CONȚINUT
•

Despre autor

• Matthew MacDonald este autor, educator și MVP Microsoft. Este autorul a mai mult de
o duzină de cărți despre programarea .NET, inclusiv Pro Silverlight 4 în C# (Apress, 2010)
și Pro WPF în C# 2010 (Apress, 2010 ). Este, de asemenea, coautor al Pro ASP.NET 4 în
C# 2010 (Apress, 2010). Locuiește în Toronto împreună cu soția și fiicele sale.

Xxv
 CONȚINUT
•

Despre revizorul tehnic

Damien Foggon este dezvoltator, scriitor și recenzent tehnic în tehnologii de ultimă oră și a contribuit la
peste 50 de cărți despre .NET, C #, Visual Basic și ASP.NET. El este cofondatorul grupului de utilizatori
NEBytes (http://www.nebytes.net) din Newcastle, este un MCPD multiplu în .NET 2.0 și .NET 3.5 și poate fi
găsit online la http://blog.littlepond.co.uk.

XXVI
 CONȚINUT
•

Aprecieri

Nici un autor nu ar putea finaliza o carte fără o mică armată de indivizi de ajutor. Sunt profund îndatorat întregii echipe
Apress, inclusiv Annei Collett, care a ajutat totul să se miște rapid și fără probleme; Kim Wimpsett, care a efectuat
editarea copiei; Damien Foggon, care a efectuat o revizuire tehnică amănunțită; și multe alte persoane care au lucrat
în spatele scenei indexând pagini, desenând figuri și corectând copia finală. Îi datorez, de asemenea, mulțumiri
speciale lui Gary Cornell, care oferă întotdeauna sfaturi neprețuite despre proiecte și lumea editorială.

Aș dori, de asemenea, să le mulțumesc celor care au fost implicați în edițiile anterioare ale acestei cărți. Printre aceștia se
numără Emma Acker și Jane Brownlow de la Osborne McGraw-Hill, precum și recenzorii tehnici anteriori Ronald Landers,
Gavin Smyth, Tim Verycruysse, Julian Skinner și Andy Olsen. De asemenea, datorez mulțumiri din inimă tuturor cititorilor care
au prins erori și și-au făcut timp să raporteze probleme și să pună întrebări bune. Continuați să trimiteți feedback-ul - vă ajută să
faceți cărți mai bune!
În cele din urmă, nu aș scrie niciodată o carte fără sprijinul soției mele și al acestor persoane speciale: Nora, Razia,
Paul și Hamid. Mulțumesc, tuturor!

XXVII
 INTRODUCERE
•

Introducere

ASP.NET este platforma Microsoft pentru dezvoltarea aplicațiilor web. Folosind ASP.NET, puteți crea magazine de
comerț electronic, site-uri portal bazate pe date și aproape orice altceva puteți găsi pe Internet. Cel mai bun dintre toate,
nu este nevoie să lipiți împreună un amestec de cod HTML și script pentru a programa Web-ul. În schimb, puteți crea
aplicații web la scară largă folosind doar cod și un instrument de proiectare, cum ar fi Visual Studio 2008.

Costul tuturor acestor inovații este curba de învățare. Pentru a stăpâni ASP.NET, trebuie să învățați cum să utilizați un
instrument avansat de proiectare (Visual Studio), un set de instrumente de obiecte (.NET Framework) și un limbaj de
programare orientat pe obiecte (cum ar fi C# 2010). Luate împreună, aceste subiecte oferă mai mult decât suficient
pentru a copleși orice dezvoltator web pentru prima dată.
Începând cu ASP.NET 4 în C# 2010 presupune că doriți să stăpâniți ASP.NET, pornind de la elementele de bază.
Folosind această carte, vă veți construi cunoștințele până când veți înțelege conceptele, tehnicile și cele mai bune
practici pentru scrierea aplicațiilor web sofisticate. Călătoria este lungă, dar este și satisfăcătoare. La sfârșitul zilei, veți
descoperi că ASP.NET vă permite să abordați provocări care sunt pur și simplu inaccesibile pe multe alte platforme.

Despre această carte

Această carte explorează ASP.NET, care este o parte esențială a Microsoft .NET Framework. .NET Framework nu este o
singură aplicație - este de fapt o colecție de tehnologii grupate într-un singur termen de marketing. .NET Framework
include limbaje precum C# 2010 și VB 2010, un motor pentru găzduirea paginilor web programabile, un model pentru
interacțiunea cu bazele de date (ADO.NET), un cadru de nivel superior pentru efectuarea interogărilor (LINQ și Entity
Framework) și o bibliotecă de clasă stocată cu instrumente pentru orice, de la citirea fișierelor până la validarea unei
parole. Pentru a stăpâni ASP.NET, trebuie să aflați despre fiecare dintre aceste ingrediente.

Această carte acoperă toate aceste subiecte de la bază. Ca rezultat, veți învăța multe tehnici care vor interesa
orice dezvoltator .NET, chiar și pe cei care creează aplicații Windows. De exemplu, veți învăța despre
programarea bazată pe componente; veți descoperi gestionarea structurată a erorilor; și veți vedea cum să
accesați fișiere, XML și baze de date relaționale. Veți învăța, de asemenea, subiectele cheie de care aveți nevoie
pentru programarea web, cum ar fi gestionarea stării, controalele web și memorarea în cache. Până la sfârșitul
acestei cărți, veți fi gata să vă creați propriile aplicații web bogate și să le faceți disponibile pe Internet.

XXVIII
 INTRODUCERE
•

Notă: Această carte are un singur scop: să fie cât mai practică posibil. Am grijă deosebită să nu te părăsesc
•
agățat în locurile în care alte cărți ASP.NET își abandonează cititorii. De exemplu, atunci când întâlnești
o nouă tehnologie, nu numai că vei afla cum funcționează, ci și de ce (și când) ar trebui să o folosești.
De asemenea, evidențiez întrebările frecvente și cele mai bune practici cu casetele tip și barele laterale
la fiecare pas. În cele din urmă, dacă un subiect este acoperit în această carte, este acoperit corect.
Aceasta înseamnă că nu veți învăța cum să efectuați o sarcină fără a afla despre potențialele
dezavantaje și problemele pe care le-ați putea întâmpina - și cum vă puteți proteja cu codul din lumea
reală.

Cine ar trebui să citească această carte

Această carte se adresează oricui dorește să creeze site-uri web dinamice cu ASP.NET. În mod ideal, veți avea
experiență cu o versiune anterioară a unui limbaj de programare, cum ar fi C sau Java. Dacă nu, ar trebui să fiți
familiarizați cu conceptele de bază de programare (bucle, structuri condiționale, matrice și așa mai departe), indiferent
dacă le-ați învățat în Visual Basic, Pascal, Turing sau un limbaj de programare complet diferit. Aceasta este singura
cerință pentru citirea acestei cărți.
Înțelegerea HTML și XHTML (limbajele de marcare utilizate pentru a scrie pagini web) vă va ajuta, dar nu este
necesară. ASP.NET funcționează la un nivel superior, permițându-vă să vă ocupați de controale web cu funcții
complete în loc de marcarea brută a paginii web. Cu toate acestea, veți obține o prezentare rapidă a
fundamentelor XHTML în capitolul 4 și veți afla despre CSS, standardul Cascading Style Sheets, în capitolul 12.

Această carte va atrage, de asemenea, programatorii care au o anumită experiență cu C# și .NET, dar nu
au lucrat cu ASP.NET în trecut. Cu toate acestea, dacă ați folosit o versiune anterioară a ASP.NET,
probabil că veți fi mai interesat de o carte cu ritm mai rapid, cum ar fi Pro ASP.NET 4 în C# 2010.

Notă Această carte începe cu fundamentele: sintaxa C#, elementele de bază ale programării orientate pe obiecte și
•
filosofia .NET Framework. Dacă nu ați mai lucrat cu C# înainte, puteți petrece puțin mai mult timp cu revizuirea
sintaxei din capitolul 2 pentru a ridica tot ce trebuie să știți. Dacă nu sunteți familiarizați cu ideile programării orientate
pe obiecte, capitolul 3 completează spațiile libere cu o revizuire rapidă, dar cuprinzătoare, a subiectului. Restul cărții
se bazează pe această fundație, de la elementele de bază ASP.NET la exemple avansate care arată tehnicile pe
care le veți folosi în aplicațiile web din lumea reală.

XXIX
 INTRODUCERE
•

ASP.NET MVC

Această carte se concentrează pe formularele web, care este modelul de bază al ASP.NET. Cu toate
acestea, Microsoft a adăugat recent un set de instrumente complet nou, numit ASP.NET
Model-View-Controller (ASP.NET MVC), care oferă un mod dramatic diferit de a construi pagini web.
Ideea de bază a ASP.NET MVC este că aplicația dvs. este separată în trei părți logice. Modelul include codul de
afaceri specific aplicației care stă la baza aplicației dvs. Vizualizarea creează o reprezentare adecvată a modelului,
convertindu-l în HTML pe care browserele îl înțeleg. Controlerul coordonează întreaga emisiune, gestionând
interacțiunile cu utilizatorul, actualizând modelul și transmițând informațiile către vizualizare. Deși acest lucru pare
destul de simplu, modelul MVC marginalizează mai multe concepte tradiționale de ASP.NET care sunt discutate în
această carte, inclusiv formularele web, controalele web, starea vizualizării, postback-urile și starea sesiunii. Pentru
unii, modelul MVC este mai curat și mai potrivit pentru Web. Pentru alții, este o mulțime de efort suplimentar, fără o
răsplată clară. Microsoft vă sugerează să luați în considerare ASP.NET MVC dacă trebuie să implementați
dezvoltarea bazată pe teste (care utilizează teste automate pentru a valida paginile web) sau dacă aveți nevoie de
control complet asupra adreselor URL și a marcajului HTML utilizat în paginile dvs.

ASP.NET MVC nu este discutat în această carte (și este un pic cam ciudat pentru
dezvoltatorii care nu sunt deja familiarizați cu ASP.NET). Cu toate acestea, puteți obține mai
multe informații de pe site-ul oficial ASP.NET MVC la http://www.asp.net/mvc sau din excelenta
carte Pro ASP.NET MVC 2 Framework de Steven Sanderson.

De ce aveți nevoie pentru a folosi această carte

Pentru a dezvolta ASP.NET pagini web, aveți nevoie de un computer cu Visual Studio 2010. Puteți utiliza ediția
gratuită Visual Studio Web Developer 2010 Express (disponibilă la http://www.microsoft.com/express), care are toate
instrumentele și funcționalitățile pe care le veți utiliza în această carte.
Pentru a utiliza o pagină web ASP.NET (cu alte cuvinte, pentru a naviga pe Internet), aveți nevoie pur și simplu de un
browser web. ASP.NET acceptă pe deplin Internet Explorer, Firefox, Opera, Safari, Google Chrome și orice alt browser care
respectă standardul HTML pe aproape orice sistem de operare. Câteva caracteristici nu vor funcționa cu browsere extrem de
vechi (cum ar fi tehnicile ASP.NET AJAX despre care veți afla în capitolul 25), dar 99% dintre navigatorii web pot folosi orice
pagină ASP.NET la maxim.
Dacă intenționați să găzduiți site-uri web pe computer, va trebui, de asemenea, să utilizați Internet
Information Services (IIS), software-ul de găzduire web care face parte din sistemul de operare Windows.
De asemenea, puteți utiliza IIS dacă doriți să testați strategiile de implementare. Veți învăța cum să utilizați
și să configurați IIS în capitolul 26. În cele din urmă, această carte include mai multe exemple care
utilizează SQL Server. Utilizați orice versiune de SQL Server pentru a încerca aceste exemple, inclusiv
ediția SQL Server Express, care este inclusă în unele versiuni de Visual Studio (și poate fi descărcată
gratuit la http://www.microsoft.com/express). Dacă utilizați alte motoare de baze de date relaționale, se vor
aplica aceleași concepte; va trebui doar să modificați codul exemplu.

Exemple de cod
Pentru a stăpâni ASP.NET, trebuie să experimentați cu ea. Una dintre cele mai bune modalități de a învăța
ASP.NET este să încercați mostrele de cod pentru această carte, să le examinați și să vă scufundați cu
propriile modificări. Pentru a obține exemplul de cod, navigați la http://www.prosetech.com sau pe site-ul
web al editorului la http://www.apress.com. Veți găsi, de asemenea, câteva linkuri către resurse
suplimentare și orice actualizări sau erate care afectează cartea.

Xxx
 INTRODUCERE
•

Prezentare generală a capitolului

Această carte este împărțită în șase părți. Dacă nu ați avut deja experiență cu .NET Framework, cel mai
productiv mod de a citi această carte este în ordine de la început până la sfârșit. Capitolele de mai târziu din
carte includ uneori caracteristici care au fost introduse mai devreme pentru a crea exemple mai bine rotunjite
și mai realiste. Pe de altă parte, dacă sunteți deja familiarizați cu platforma .NET, C# și programarea orientată
pe obiecte, veți face o scurtă lucrare din prima parte a acestei cărți.

Partea 1: Introducerea .NET

Puteți începe să codificați imediat o aplicație ASP.NET urmând exemplele din a doua parte a acestei cărți. Dar
pentru a stăpâni cu adevărat ASP.NET, trebuie să înțelegeți câteva concepte fundamentale despre .NET
Framework.
Capitolul 1 sortează jargonul Microsoft și explică ce face cu adevărat .NET Framework și de ce aveți
nevoie de el. Capitolul 2 vă prezintă C# cu un tur lingvistic cuprinzător. În cele din urmă, capitolul 3 explică
elementele de bază ale programării moderne orientate pe obiecte.

Partea 2: Dezvoltarea aplicațiilor ASP.NET

A doua parte a acestei cărți pătrunde în inima programării ASP.NET și introduce noul său model bazat pe evenimente. În
capitolul 4, veți arunca o privire în jurul mediului de proiectare Visual Studio și veți afla câteva elemente fundamentale
despre formulare web, evenimente și XHTML. În capitolele 5 și 6, învățați cum să programați interfața cu utilizatorul a
unei pagini web printr-un strat de obiecte numit controale de server.
În continuare, veți explora încă două elemente esențiale ale programării ASP.NET. Capitolul 7 prezintă
diferite tehnici de tratare a erorilor. Capitolul 8 descrie diferite strategii pentru gestionarea statului. Luate
împreună, capitolele din această parte conțin toate conceptele de bază de care aveți nevoie pentru a
proiecta pagini web și pentru a crea un site web de ASP.NET de bază.

Partea 3: Crearea unor formulare web mai bune

A treia parte a acestei cărți explorează mai multe subiecte care vă pot ajuta să transformați paginile web
obișnuite în aplicații web lustruite. În capitolul 9, veți învăța să utilizați controalele de validare pentru a detecta
date nevalide înainte ca utilizatorul să le trimită. În capitolul 10 veți trece la luarea în considerare a unora
dintre controalele mai exotice ale ASP.NET, cum ar fi Calendarul și Expertul. În capitolul 11, veți învăța cum
să vă construiți propriile blocuri reutilizabile de interfață cu utilizatorul paginii web și să desenați grafică
personalizată din mers. În cele din urmă, capitolul 12 arată cum puteți standardiza aspectul unui întreg site
web cu teme și pagini coordonatoare, iar capitolul 13 vă arată cum să adăugați navigare pe un site web.

Partea 4: Lucrul cu datele

Aproape toate software-urile trebuie să funcționeze cu date, iar aplicațiile web nu fac excepție. În capitolul 14,
începeți să explorați lumea datelor luând în considerare ADO.NET - Microsoft. Tehnologie bazată pe NET
pentru interacțiunea cu bazele de date relaționale. Capitolele 15 și 16 explică modul de utilizare a legării
datelor și controalele avansate ale datelor ASP.NET pentru a crea pagini web care integrează afișaje de date
atractive, personalizabile, cu suport automat pentru paginare, sortare și editare.

Numărul de tipuri diferite

 INTRODUCERE
•

Capitolul 17 iese din lumea bazelor de date și analizează modul de interacțiune cu fișierele. Capitolul 18
lărgește imaginea și mai mult și descrie modul în care ASP.NET aplicații pot utiliza suportul XML
încorporat în .NET Framework.

Partea 5: Securitatea site-ului web

Fiecare site web public trebuie să se ocupe de securitate, asigurându-se că datele sensibile nu pot fi
accesate de utilizatorii nepotriviți. În capitolul 19, veți începe să învățați cum ASP.NET oferă diferite sisteme
de autentificare pentru tratarea utilizatorilor. Puteți scrie propria logică particularizată pentru a verifica
numele de utilizator și parolele sau puteți utiliza informațiile de cont Windows existente. În capitolul 20, veți
afla despre modelul de membru, care extinde sistemul de autentificare cu controale de securitate
predefinite și obiecte la îndemână care automatizează sarcinile comune. Dacă doriți, puteți obține chiar
ASP.NET pentru a crea și gestiona automat o bază de date cu informații despre utilizator. În cele din urmă,
capitolul 21 se ocupă de un alt supliment - modelul de profiluri care vă permite să stocați informații pentru
fiecare utilizator automat, fără a scrie niciun cod de bază de date.

Partea 6: ASP.NET avansată

Această parte include subiectele avansate pe care le puteți utiliza pentru a vă duce aplicațiile web la un pas suplimentar.
Capitolul 22 se referă la modul în care puteți crea componente reutilizabile pentru aplicații ASP.NET. Capitolul 23
demonstrează modul în care utilizarea atentă a cache-ului poate spori performanța aproape a oricărei aplicații web. Capitolul
24 explorează LINQ și Entity Framework, două caracteristici care vă permit să interacționați cu o bază de date fără a scrie o
grămadă de cod personalizat. Capitolul 25 introduce ASP.NET AJAX, care vă permite să construiți pagini web receptive care
adaugă funcții bogate, cum ar fi completarea automată a textului și drag-and-drop. În cele din urmă, capitolul 26 vă prezintă
pașii pentru implementarea aplicației pe un server web.

Feedback
Această carte are obiectivul ambițios de a fi cel mai bun tutorial și referință pentru ASP.NET. În acest scop,
comentariile și sugestiile dvs. sunt extrem de utile. Puteți trimite reclamații, adulație și orice altceva între ele
direct către apress@prosetech.com. Nu pot să vă rezolv problemele ASP.NET sau să vă critic codul, dar
beneficiez de informații despre ceea ce a făcut această carte bine și rău (și ce ar fi putut face într-un mod
complet confuz). De asemenea, puteți trimite comentarii despre suportul site-ului web pentru această carte.

XXXII
PART1

• ■■

Vă prezentăm .NET
CAPITOLUL1

• ■■

The .NET Framework

Microsoft are o reputație onorată de-a lungul timpului pentru crearea de tehnologii inovatoare și împachetarea lor în
cuvinte cheie care derutează pe toată lumea. .NET Framework este cel mai recent exemplu - a fost descris ca o clonă
Java slabă, un termen de marketing fără sens și o încercare de a prelua internetul cu tehnologie proprietară. Dar
niciuna dintre aceste descrieri nu este cu adevărat exactă.
.NET este de fapt un grup de tehnologii - unele revoluționare, altele nu - care sunt concepute pentru a ajuta dezvoltatorii
să construiască o varietate de tipuri diferite de aplicații. Dezvoltatorii pot utiliza .NET Framework pentru a construi
aplicații Windows îmbogățite, servicii care rulează silențios în fundal și chiar instrumente de linie de comandă. Desigur,
dacă citiți această carte, sunteți cel mai interesat să utilizați .NET pentru a crea aplicații web. Pentru aceasta, veți utiliza
un subset specific al .NET Framework numit ASP.NET și veți lucra cu unul dintre . Limbile de bază ale NET: C#.

În acest capitol, veți examina tehnologiile care stau la baza .NET. În primul rând, veți arunca o privire rapidă
asupra istoriei dezvoltării web și veți afla de ce a fost creat .NET Framework. Apoi, veți obține o imagine de
ansamblu la nivel înalt a diferitelor părți ale .NET și veți vedea cum se potrivește ASP.NET 4 în imagine.

Evoluția dezvoltării web

Internetul a început la sfârșitul anilor 1960 ca un experiment. Scopul său a fost de a crea o rețea de informații cu
adevărat rezistentă - una care ar putea rezista pierderii mai multor computere fără a împiedica celelalte să comunice.
Condus de potențiale scenarii de dezastru (cum ar fi un atac nuclear), Departamentul Apărării al SUA a furnizat
finanțarea inițială.
Internetul timpuriu a fost în mare parte limitat la instituțiile de învățământ și contractorii din domeniul apărării.
A înflorit ca un instrument de colaborare academică, permițând cercetătorilor din întreaga lume să
împărtășească informații. La începutul anilor 1990, au fost create modemuri care ar putea funcționa pe liniile
telefonice existente, iar Internetul a început să se deschidă utilizatorilor comerciali. În 1993, a fost creat primul
browser HTML și a început revoluția internetului.

Formulare HTML și HTML

Ar fi dificil să descriem site-urile web timpurii ca aplicații web. În schimb, prima generație de site-uri web arăta
adesea mai mult ca niște broșuri, constând în mare parte din pagini HTML fixe care trebuiau actualizate manual.

O pagină HTML de bază seamănă puțin cu un document de procesare a textului - conține conținut formatat
care poate fi afișat pe computer, dar de fapt nu face nimic. Următorul exemplu arată HTML la modul cel mai
simplu, cu un document care conține un titlu și o singură linie de text:

3
 CAPITOLUL CADRUL .NET
1

<html> <head> <title>Sample Web Page</title>

</head> <body> <h1>Sample Web Page
Heading</h1> <p>Aceasta este o pagină web
eșantion.</p> </body>

</html>

Un document HTML are două tipuri de conținut: textul și elementele (sau etichetele) care spun browserului
cum să-l formateze. Elementele sunt ușor de recunoscut, deoarece sunt desemnate cu paranteze înclinate (<
>). HTML definește elemente pentru diferite niveluri de titluri, paragrafe, hyperlinkuri, formatare cursivă și
aldină, linii orizontale și așa mai departe. De exemplu, <h1>Unele text</ h1> utilizează elementul <h1>. Acest
element indică browserului să afișeze un text în stilul Titlu 1, care utilizează un font mare, aldin. În mod
similar, <p>Aceasta este o pagină web eșantion.</p> creează un paragraf cu o linie de text. Elementul <cap>
grupează informațiile antetului împreună și include elementul <titlu> cu textul care apare în fereastra
browserului, în timp ce elementul <corp> grupează împreună conținutul real al documentului afișat în fereastra
browserului. Figura 1-1 prezintă această pagină HTML simplă într-un browser. În acest moment, acesta este
doar un fișier fix (numit SampleWebPage.htm) care conține conținut HTML. Nu are interactivitate, nu necesită
un server web și, cu siguranță, nu poate fi considerată o aplicație web.

Figura 1-1. HTML obișnuit

4
 CAPITOLUL CADRUL .NET
1

Sfat
• Nu este necesar să stăpâniți HTML pentru a programa ASP.NET pagini web, deși este
adesea util. Pentru o introducere rapidă în HTML, consultați unul dintre tutorialele HTML
excelente de pe Internet, cum ar fi http://www.w3schools.com/html. Veți primi, de asemenea, o
mini-introducere în elementele HTML din capitolul 4.

HTML 2.0 a introdus prima sămânță de programare web cu o tehnologie numită formulare HTML.
Formularele HTML extind HTML astfel încât să includă nu numai etichete de formatare, ci și etichete
pentru widgeturi grafice sau controale. Aceste controale includ ingrediente comune, cum ar fi liste
derulante, casete text și butoane. Iată un exemplu de pagină web creată cu controale de formular HTML:
<html> <head> <title>Exemplu de pagină
web</title> </head> <body> <form>

<input type="checkbox" /> Aceasta este alegerea #1<br />

<input type="checkbox" /> Aceasta este alegerea #2<br /><br />

<input type="submit" value="Submit" /> </form>

</body> </html>

Într-un formular HTML, toate controalele sunt plasate între etichetele <formular> și </formular>. Exemplul
precedent include două casete de selectare (reprezentate de elementul <input type="checkbox"/>) și un
buton (reprezentat de elementul <input type="submit"/> ). Elementul <br /> adaugă un sfârșit de linie între
linii. Într-un browser, această pagină arată ca Figura 1-2.
 CAPITOLUL CADRUL .NET
1

Figura 1-2. Un formular HTML

Formularele HTML permit dezvoltatorilor web să proiecteze pagini de intrare standard. Când utilizatorul face clic pe
butonul Trimitere de pe pagina prezentată în Figura 1-2, toate datele din controalele de introducere (în acest caz, cele
două casete de selectare) sunt corectate împreună într-un șir lung de text și trimise serverului web. Pe partea de server,
o aplicație personalizată primește și procesează datele.
Destul de uimitor, controalele care au fost create pentru formularele HTML cu mai mult de zece ani în urmă
sunt încă fundația de bază pe care o veți folosi pentru a construi pagini ASP.NET dinamice! Diferența este
tipul de aplicație care rulează pe partea serverului. În trecut, când utilizatorul făcea clic pe un buton de pe o
pagină de formular, informațiile ar fi putut fi trimise prin e-mail către un cont setat sau trimise către o aplicație
de pe server care utiliza standardul provocator Common Gateway Interface (CGI). Astăzi, veți lucra cu
platforma ASP.NET mult mai capabilă și mai elegantă.

Programare pe partea de server

Primele platforme de dezvoltare web au avut două probleme cheie. În primul rând, nu au scalat întotdeauna bine.
Drept urmare, site-urile populare s-ar lupta să țină pasul cu cererea prea multor utilizatori simultani, în cele din urmă
prăbușindu-se sau încetinind la un crawl. În al doilea rând, au oferit puțin mai mult decât un mediu de programare
simplu. Dacă doreați caracteristici de nivel superior, cum ar fi capacitatea de a autentifica utilizatorii, de a stoca
informații personalizate sau de a afișa înregistrările pe care le-ați recuperat dintr-o bază de date, trebuia să scrieți
pagini de cod de la zero. Construirea unei aplicații web în acest fel este obositoare și predispusă la erori.
Pentru a contracara aceste probleme, Microsoft a creat platforme de dezvoltare de nivel superior, mai întâi ASP și apoi
ASP.NET. Ambele tehnologii permit dezvoltatorilor să programeze pagini web dinamice fără să se îngrijoreze de
detaliile de implementare la nivel scăzut. Din acest motiv, ambele platforme au avut un succes incredibil.

Platforma originală ASP a obținut o audiență uriașă de aproape 1 milion de dezvoltatori, devenind mult mai populară
decât anticipa Microsoft. Nu a trecut mult timp până când a fost prins în tot felul de locuri neobișnuite, inclusiv aplicații de

6
 CAPITOLUL CADRUL .NET
1

afaceri critice și site-uri de comerț electronic foarte traficate. Deoarece ASP nu a fost proiectat având în vedere
aceste utilizări, au apărut în curând probleme de performanță, securitate și configurare.
Aici intervine ASP.NET în imagine. ASP.NET a fost dezvoltat ca un cadru de aplicații web puternic industrial,
care ar putea aborda limitările ASP. În comparație cu ASP clasic, ASP.NET oferă performanțe mai bune,
instrumente de proiectare mai bune și un set bogat de caracteristici gata făcute. ASP.NET a fost extrem de
popular din momentul în care a fost lansat - de fapt, a fost pus la lucru în zeci de site-uri comerciale la scară
largă în timp ce era încă în versiune beta.

Notă: În ciuda faptului că au baze similare, ASP și ASP.NET sunt radical diferite. ASP este bazat pe script
•
limbaj de programare care necesită o înțelegere aprofundată a HTML și o bună cantitate de
codificare dureroasă. ASP.NET, pe de altă parte, este un model de programare orientat pe
obiecte care vă permite să creați o pagină web la fel de ușor cum ați construi o aplicație
Windows.

Programare pe partea clientului

În același timp în care dezvoltarea web pe partea de server se deplasa printr-o supă alfabetică de tehnologii,
un nou tip de programare câștiga popularitate. Dezvoltatorii au început să experimenteze diferite moduri în
care ar putea îmbunătăți paginile web prin încorporarea applet-urilor miniaturale construite cu JavaScript,
ActiveX, Java și Flash în paginile web. Aceste tehnologii din partea clientului nu implică nicio procesare a
serverului. În schimb, aplicația completă este descărcată în browserul client, care o execută local.
Cea mai mare problemă cu tehnologiile din partea clientului este că acestea nu sunt acceptate în mod egal de toate browserele
și sistemele de operare. Unul dintre motivele pentru care dezvoltarea web este atât de populară în primul rând este că aplicațiile
web nu necesită CD-uri de configurare, descărcări, configurare pe partea client și alți pași de implementare plictisitori (și
predispuși la erori). În schimb, o aplicație web poate fi utilizată pe orice computer care are acces la Internet. Dar atunci când
dezvoltatorii folosesc tehnologii din partea clientului, se confruntă cu câteva dureri de cap familiare. Dintr-o dată,
compatibilitatea cross-browser devine o problemă. Dezvoltatorii sunt forțați să-și testeze site-urile web cu diferite sisteme de
operare și browsere și să se ocupe de o gamă largă de ciudățenii ale browserului, bug-uri și comportamente moștenite. Cu alte
cuvinte, modelul client-side sacrifică unele dintre cele mai importante beneficii ale dezvoltării web.

Din acest motiv, ASP.NET este conceput în primul rând ca o tehnologie pe partea de server. Tot codul
ASP.NET se execută pe server. Când codul este terminat de executat, utilizatorul primește o pagină HTML
obișnuită, care poate fi vizualizată în orice browser. Figura 1-3 prezintă diferența dintre modelele de pe
server și cele de pe partea clientului.

7
 CAPITOLUL CADRUL .NET
1
Descărcați de la Wow! eBook <www.wowebook.com>

Figura 1-3. Aplicații web pe partea serverului și pe partea clientului

Acestea sunt alte câteva motive pentru evitarea programării pe partea clientului:

Izolare: Codul pe partea client nu poate accesa resursele de pe server. De exemplu, o aplicație din
partea clientului nu are o modalitate ușoară de a citi un fișier sau de a interacționa cu o bază de date de
pe server (cel puțin nu fără a întâmpina probleme cu securitatea și compatibilitatea browserului).
Securitate: Utilizatorii finali pot vizualiza codul pe partea client. Și odată ce utilizatorii rău
intenționați înțeleg cum funcționează o aplicație, o pot manipula adesea.

8
 CAPITOLUL CADRUL .NET
1

Clienți subțiri: În lumea de astăzi, dispozitivele web, cum ar fi telefoanele mobile, computerele portabile și
asistenții personali digitali (PDA) sunt omniprezente. Aceste dispozitive au, de obicei, un fel de capacitate de
navigare web încorporată, dar nu acceptă toate caracteristicile browserelor tradiționale bazate pe desktop. De
exemplu, clienții subțiri ar putea să nu accepte caracteristici din partea clientului, cum ar fi JavaScript și Flash.

Cu toate acestea, programarea pe partea clientului nu este cu adevărat moartă. În multe cazuri, ASP.NET vă permite să
combinați cele mai bune programe din partea clientului cu programarea de pe server. De exemplu, cele mai bune controale de
ASP.NET pot detecta în mod inteligent caracteristicile browserului client. Dacă browserul acceptă JavaScript, aceste controale
vor returna o pagină web care încorporează JavaScript pentru o interfață de utilizator mai bogată și mai receptivă. Și în capitolul
25, veți afla cum puteți supraîncărca paginile obișnuite de ASP.NET cu funcții Ajax, care utilizează și mai mult JavaScript din
partea clientului. Răsucirea este că ASP.NET are grijă de codificarea complexă pe mai multe platforme, asigurându-se că
paginile dvs. web funcționează pe toate browserele moderne.
Cu toate acestea, este important să înțelegem un fapt fundamental. Indiferent de capacitățile browserului,
codul C# este întotdeauna executat pe server. Bibelourile din partea clientului sunt doar cireașa de pe tort.

The .NET Framework

După cum ați aflat deja, .NET Framework este într-adevăr un cluster de mai multe tehnologii:

Limbajele .NET: Acestea includ Visual Basic, C#, F# și C++.

Common Language Runtime (CLR): Acesta este motorul care execută toate programele .NET și
oferă servicii automate pentru aceste aplicații, cum ar fi verificarea securității, gestionarea
memoriei și optimizarea.
Biblioteca de clase .NET Framework: Biblioteca de clase colectează mii de piese de funcționalitate
predefinite pe care le puteți "fixa" la aplicațiile dvs. Aceste caracteristici sunt uneori organizate în seturi
de tehnologii, cum ar fi ADO.NET (tehnologia pentru crearea aplicațiilor de baze de date) și Windows
Presentation Foundation (WPF, tehnologia pentru crearea interfețelor desktop cu utilizatorul).
ASP.NET: Acesta este motorul care găzduiește aplicațiile web pe care le creați cu .NET și acceptă
aproape orice caracteristică din biblioteca de clase .NET Framework. ASP.NET include, de
asemenea, un set de servicii specifice web, cum ar fi autentificarea securizată și stocarea datelor.
Visual Studio: Acest instrument opțional de dezvoltare conține un set bogat de caracteristici de
productivitate și depanare. Visual Studio include .NET Framework complet, deci nu va trebui să îl
descărcați separat.

Uneori, diviziunea dintre aceste componente nu este clară. De exemplu, termenul ASP.NET este uneori folosit într-un
sens restrâns pentru a se referi la porțiunea bibliotecii de clase .NET utilizată pentru proiectarea paginilor web. Pe de altă
parte, ASP.NET se referă, de asemenea, la întregul subiect al aplicațiilor web .NET, care include limbaje .NET și multe
piese fundamentale ale bibliotecii de clase care nu sunt specifice web. (Acesta este, în general, modul în care folosim
termenul în această carte. Examinarea noastră exhaustivă a ASP.NET include elementele de bază .NET, limbajul C# și
subiecte pe care orice dezvoltator .NET le-ar putea utiliza, cum ar fi programarea bazată pe componente și accesul la
baza de date.)
Figura 1-4 prezintă biblioteca de clase .NET și CLR - cele două părți fundamentale ale .NET.

9
 CAPITOLUL CADRUL .NET
1

Figura 1-4. .NET Framework

10
 CAPITOLUL CADRUL .NET
1

În restul acestui capitol, veți arunca o privire rapidă asupra diferitelor ingrediente care alcătuiesc .NET
Framework.

Limbile C#, VB și .NET

Această carte folosește C#, limbajul preferat Microsoft .NET. C# seamănă cu Java și C++ în sintaxă, dar nu există o cale
directă de migrare din Java sau C++.
Interesant este că VB și C # sunt de fapt destul de asemănătoare. Deși sintaxa este diferită, atât VB cât și C#
utilizează biblioteca de clase .NET și sunt acceptate de CLR. De fapt, aproape orice bloc de cod C# poate fi
tradus, linie cu linie, într-un bloc echivalent de cod VB (și invers). O diferență ocazională de limbă apare, dar, în
cea mai mare parte, un dezvoltator care a învățat un limbaj .NET poate trece rapid și eficient la altul.

Pe scurt, atât VB cât și C# sunt limbaje elegante, moderne, ideale pentru crearea următoarei
generații de aplicații web.

• Notă . NET 1.0 a introdus limbi complet noi. Cu toate acestea, modificările din versiunile
ulterioare ale .NET au fost mai subtile. Deși versiunea C# din .NET 4 adaugă câteva caracteristici
noi, majoritatea părților limbajului rămân neschimbate. În capitolele 2 și 3, veți sorta sintaxa C# și
veți învăța elementele de bază ale programării orientate pe obiecte.

Limba intermediară
Toate limbajele .NET sunt compilate într-un alt limbaj de nivel inferior înainte de executarea codului. Acest limbaj de nivel
inferior este limba intermediară comună (CIL sau doar IL). CRJ, motorul .NET, folosește doar codul IL. Deoarece toate
limbajele .NET sunt proiectate pe baza IL, toate au asemănări profunde. Acesta este motivul pentru care limbajele VB și
C# oferă în esență aceleași caracteristici și performanțe. De fapt, limbile sunt atât de compatibile încât o pagină web
scrisă cu C# poate folosi o componentă VB în același mod în care folosește o componentă C# și invers.

.NET Framework formalizează această compatibilitate cu ceva numit Common Language Specification (CLS). În esență,
CLS este un contract care, dacă este respectat, garantează că o componentă scrisă într-un limbaj .NET poate fi utilizată
în toate celelalte. O parte a CLS este sistemul de tip comun (CTS), care definește regulile pentru tipurile de date, cum ar
fi șirurile, numerele și matricele, care sunt partajate în toate limbile .NET. CLS definește, de asemenea, ingrediente
orientate pe obiecte, cum ar fi clase, metode, evenimente și multe altele. În cea mai mare parte, dezvoltatorii .NET nu
trebuie să se gândească la modul în care funcționează CLS, chiar dacă se bazează pe el în fiecare zi.

Figura 1-5 arată modul în care limbile .NET sunt compilate în IL. Fiecare fișier EXE sau DLL pe care îl
construiți cu un limbaj .NET conține cod IL. Acesta este fișierul pe care îl implementați pe alte computere.
În cazul unei aplicații web, implementați codul compilat pe un server web live.

11
 CAPITOLUL CADRUL .NET
1

Figura 1-5. Compilarea limbilor în .NET

12
 CAPITOLUL CADRUL .NET
1

CLR rulează numai codul IL, ceea ce înseamnă că nu are idee ce limbaj .NET ați folosit inițial. Observați,
totuși, că CLR efectuează de fapt un alt pas de compilare - ia codul IL și îl transformă în cod nativ de limbaj
mașină adecvat pentru platforma curentă. Acest pas apare atunci când aplicația este lansată, chiar înainte
ca codul să fie executat efectiv. Într-o aplicație ASP.NET, aceste fișiere specifice computerului sunt
memorate în cache în timp ce aplicația web rulează, astfel încât să poată fi reutilizate, asigurând performanțe
optime.

Notă aparatului
• codul S-ar puteadepinde
să vă întrebați
de mai de ce factori,
mulți compilatoarele .NET
inclusiv de nu compilează
CPU. direct
În cazul în care în codulomașinii. Motivul este
compilați
aplicație la codul mașinii pe un computer, nu există nicio garanție că va funcționa pe un alt
computer cu un procesor diferit.

Timpul de rulare al limbii comune

CLR este motorul care acceptă toate limbile .NET. Multe limbi moderne folosesc timpi de rulare. În VB 6,
logica runtime este conținută într-un fișier DLL numit msvbvm60.dll. În C++, multe aplicații se leagă la un fișier
numit mscrt40.dll pentru a obține funcționalități comune. Aceste runtime pot furniza biblioteci utilizate de
limbaj sau pot avea responsabilitatea suplimentară de a executa codul (ca și în cazul Java). Runtime-urile nu
sunt nimic nou, dar CLR este cel mai ambițios runtime al Microsoft până în prezent. CLR nu numai că execută
cod, dar oferă și un întreg set de servicii conexe, cum ar fi verificarea codului, optimizarea și gestionarea
obiectelor.

• Notă CLR este motivul pentru care unii dezvoltatori au acuzat .NET că este o clonă Java.
Afirmația este destul de prostească. Este adevărat că .NET este destul de similar cu Java în
aspecte cheie (ambele utilizează un mediu special gestionat și oferă caracteristici printr-o
bibliotecă bogată de clase), dar este, de asemenea, adevărat că fiecare limbaj de programare
"fură" și îmbunătățește limbajele de programare anterioare. Aceasta include Java, care a adoptat
părți ale limbajului C / C ++ și sintaxei atunci când a fost creat. Desigur, în multe alte aspecte,
.NET diferă la fel de radical de Java ca și de VBScript.

Tot codul .NET rulează în interiorul CLR. Acest lucru este valabil indiferent dacă rulați o aplicație Windows
sau un serviciu web. De exemplu, atunci când un client solicită o pagină web ASP.NET, serviciul ASP.NET
rulează în mediul CLR, execută codul și creează o pagină HTML finală pentru a o trimite clientului. Implicațiile
CRJ sunt ample:

Integrare profundă a limbajului: VB și C#, la fel ca toate limbajele .NET, compilează în IL. Cu alte
cuvinte, CRJ nu face nicio distincție între diferite limbaje – de fapt, nu are cum să știe ce limbaj a fost
folosit pentru a crea un executabil. Aceasta este mult mai mult decât simpla compatibilitate lingvistică;
Este integrarea lingvistică.
Execuție side-by-side: CLR are, de asemenea, capacitatea de a încărca mai multe versiuni ale unei componente simultan.
Cu alte cuvinte, puteți actualiza o componentă de mai multe ori, iar versiunea corectă va fi încărcată și utilizată pentru
fiecare aplicație. Ca efect secundar, pot fi instalate mai multe versiuni ale .NET Framework, ceea ce înseamnă că puteți

13
 CAPITOLUL CADRUL .NET
1

face upgrade la versiuni noi de ASP.NET fără a înlocui versiunea curentă sau a fi nevoie să rescrieți aplicațiile.

Mai puține erori: Categorii întregi de erori sunt imposibile cu CRJ. De exemplu, CLR previne multe
greșeli de memorie care sunt posibile cu limbaje de nivel inferior, cum ar fi C ++.

Împreună cu aceste beneficii cu adevărat revoluționare, CRJ are unele dezavantaje potențiale. Iată trei
probleme care sunt adesea ridicate de dezvoltatorii noi, dar la care nu se răspunde întotdeauna:

Performanță: O aplicație ASP.NET tipică este mult mai rapidă decât o aplicație ASP comparabilă, deoarece
codul ASP.NET este compilat în codul mașinii înainte de a fi executat. Cu toate acestea, algoritmii de
procesare încă nu se pot potrivi cu viteza orbitoare a codului C ++ bine scris, deoarece CLR impune unele
cheltuieli suplimentare. În general, acesta este un factor doar în câteva aplicații critice pentru performanță,
cu volum mare de lucru (cum ar fi jocurile în timp real). Cu aplicațiile web de volum mare, blocajele
potențiale sunt rareori legate de procesor, dar sunt de obicei legate de viteza unei resurse externe, cum ar fi
o bază de date sau sistemul de fișiere al serverului web. Cu ASP.NET cache și un cod de bază de date bine
scris, puteți asigura performanțe excelente pentru orice aplicație web.
Transparența codului: IL este mult mai ușor de dezasamblat, ceea ce înseamnă că, dacă distribuiți o
aplicație sau o componentă compilată, alți programatori pot avea un timp mai ușor să determine modul
în care funcționează codul dvs. Aceasta nu este o problemă prea mare pentru aplicațiile ASP.NET,
care nu sunt distribuite, dar sunt găzduite pe un server web securizat.
Suport discutabil pentru mai multe platforme: Datorită proiectului Mono (a se vedea http://www.mono-
project.com), dezvoltatorii pot utiliza o implementare gratuită a .NET care rulează pe Linux, Unix, Mac
OS și Windows. Cu toate acestea, Mono este susținut de comunitatea open source, nu de Microsoft, și
nu oferă toate . Caracteristicile NET. Din acest motiv, puține companii folosesc Mono în loc de .NET.

Biblioteca de clase .NET

Biblioteca de clase .NET este un depozit gigant de clase care oferă funcționalități prefabricate pentru orice, de la citirea
unui fișier XML până la trimiterea unui mesaj de poștă electronică. Dacă ați avut vreo expunere la Java, este posibil să
fiți deja familiarizați cu ideea unei biblioteci de clasă. Cu toate acestea, biblioteca de clase .NET este mai ambițioasă și
mai cuprinzătoare decât aproape orice alt cadru de programare. Orice limbaj .NET poate utiliza caracteristicile
bibliotecii de clasă .NET interacționând cu obiectele potrivite. Acest lucru ajută la încurajarea consecvenței între diferite
limbi .NET și elimină necesitatea de a instala numeroase componente pe computer sau pe serverul web.

Unele părți ale bibliotecii de clase includ caracteristici pe care nu va trebui să le utilizați niciodată în aplicațiile web (cum ar fi
clasele utilizate pentru a crea aplicații desktop cu interfețe Windows). Alte părți ale bibliotecii clasei vizează direct dezvoltarea
web. Și mai multe clase pot fi utilizate în diverse scenarii de programare și nu sunt specifice dezvoltării web sau Windows.
Acestea includ setul de bază de clase care definesc tipurile comune de variabile și clasele pentru accesul la date, pentru a
numi doar câteva. Veți explora .NET Framework pe parcursul acestei cărți.

Vă puteți gândi la biblioteca de clasă ca la un set de instrumente al programatorului bine aprovizionat.

Filozofia Microsoft este că va oferi infrastructura obositoare, astfel încât dezvoltatorii de aplicații trebuie
doar să scrie cod specific afacerii. De exemplu, .NET Framework se ocupă de probleme spinoase, cum ar fi
tranzacțiile bazei de date și concurența, asigurându-se că sute sau mii de utilizatori simultani pot solicita
aceeași pagină web simultan. Trebuie doar să adăugați logica necesară pentru aplicația dvs. specifică.

14
 CAPITOLUL CADRUL .NET
1

Visual Studio
Ultima parte a .NET este instrumentul de dezvoltare Visual Studio, care oferă un mediu bogat în care
puteți crea rapid aplicații avansate. Deși, teoretic, ați putea crea o aplicație ASP.NET fără Visual Studio
(de exemplu, scriind tot codul sursă într-un editor de text și compilându-l cu . compilatoarele de linie de
comandă ale NET), această sarcină ar fi plictisitoare, dureroasă și predispusă la erori. Din acest motiv, toți
dezvoltatorii profesioniști de ASP.NET folosesc un instrument de proiectare precum Visual Studio. Unele
dintre caracteristicile Visual Studio includ următoarele:
Proiectarea paginilor: Puteți crea o pagină atractivă cu ușurință prin glisare și plasare utilizând
designerul de formulare web integrat în Visual Studio. Nu trebuie să înțelegeți HTML.
Detectarea automată a erorilor: Puteți economisi ore de lucru atunci când Visual Studio detectează și
raportează o eroare înainte de a rula aplicația. Problemele potențiale sunt subliniate, la fel ca funcția
"spell-as-you-go" găsită în multe procesoare de text.
Instrumente de depanare: Visual Studio își păstrează instrumentele legendare de depanare, care vă
permit să urmăriți codul în acțiune și să urmăriți conținutul variabilelor. Și puteți testa aplicațiile web la
fel de ușor ca orice alt tip de aplicație, deoarece Visual Studio are un server web încorporat care
funcționează doar pentru depanare.
IntelliSense: Visual Studio furnizează completarea instrucțiunilor pentru obiectele recunoscute și
listează automat informații, cum ar fi parametrii funcției, în sfaturi ecran utile.

Nu trebuie să utilizați Visual Studio pentru a crea aplicații web. De fapt, ați putea fi tentați să utilizați .NET
Framework descărcabil gratuit și un editor de text simplu pentru a crea pagini web și servicii web ASP.NET.
Cu toate acestea, făcând acest lucru, vă veți multiplica munca și veți avea mult mai greu depanarea,
organizarea și întreținerea codului. Capitolul 4 prezintă cea mai recentă versiune de Visual Studio.
Visual Studio este disponibil în mai multe ediții:

Visual Web Developer Express: Aceasta este o versiune complet gratuită a Visual Studio, care este
surprinzător de capabilă; include chiar și SQL Server Express, un motor de baze de date gratuit pe
care îl puteți utiliza pentru a alimenta site-uri web mici. Principala sa limitare este că vă permite să
construiți numai aplicații și componente web, nu și alte tipuri de programe .NET (cum ar fi aplicațiile
Windows).

Sfat: Pentru
• Pentru a descărca
a compara Visual Web
diferențele Developer
dintre Express,
versiunile Visualnavigați
Studio,pe
consultați
http://www.microsoft.com/express/downloads.

http://www.microsoft.com/visualstudio/products.

Visual Studio Professional: Aceasta este cea mai slabă versiune completă a Visual Studio. Are toate
caracteristicile de care aveți nevoie pentru a construi orice tip de aplicație .NET (Windows sau web).
Visual Studio Premium, Ultimate sau Test Professional: Aceste versiuni cresc costul și adună mai
multe instrumente și bibelouri (care nu sunt discutate în această carte). De exemplu, acestea
încorporează funcții pentru testarea automată și controlul versiunilor, ceea ce îi ajută pe membrii
echipei să își coordoneze activitatea pe proiecte mari.
 CAPITOLUL CADRUL .NET
1

• Notă Veți putea rula toate exemplele din această carte utilizând orice versiune de Visual
Studio, inclusiv Visual Web Developer Express gratuit.

Ultimul cuvânt
Acest capitol a prezentat o prezentare generală la nivel înalt care v-a oferit prima idee despre ASP.NET și .NET
Framework. De asemenea, ați analizat modul în care a evoluat dezvoltarea web, de la standardul de bază al formularelor
HTML la platforma modernă de ASP.NET.
În capitolul următor, veți obține o imagine de ansamblu cuprinzătoare a limbajului C #.

16
CAPITOLUL2

•■■

Limbajul C#

Înainte de a putea crea o aplicație ASP.NET, trebuie să alegeți o limbă .NET în care să o programați. Dacă sunteți un
dezvoltator ASP sau VB, alegerea naturală este VB 2010. Dacă sunteți un programator Java de lungă durată sau un
programator C de mână veche sau dacă doriți doar să învățați limba oficială a .NET, C # vi se va potrivi cel mai bine.
Acest capitol prezintă o prezentare generală a limbajului C#. Veți afla despre tipurile de date pe care le puteți utiliza,
operațiile pe care le puteți efectua și codul de care veți avea nevoie pentru a defini funcții, bucle și logică condițională.
Acest capitol presupune că ați programat înainte și sunteți deja familiarizați cu majoritatea acestor concepte - trebuie doar
să vedeți cum sunt implementate în C #.
Dacă ați programat cu un limbaj similar, cum ar fi Java, s-ar putea să descoperiți că cel mai benefic mod de a
utiliza acest capitol este să navigați prin el fără a citi fiecare secțiune. Această abordare vă va oferi o imagine
de ansamblu generală a limbajului C#. Apoi puteți reveni la acest capitol mai târziu ca referință, atunci când
este necesar. Dar amintiți-vă, deși puteți programa o aplicație ASP.NET fără a stăpâni toate detaliile
limbajului, această cunoaștere profundă este adesea ceea ce separă programatorul ocazional de legendarul
guru de programare.

Notă Exemplele din acest capitol prezintă linii individuale și fragmente de cod. De fapt, nu veți putea utiliza
•
aceste fragmente de cod într-o aplicație până când ați aflat despre obiecte și tipuri .NET. Dar nu
disperați - următorul capitol se bazează pe aceste informații, umple golurile și prezintă un
exemplu ASP.NET pe care să-l încercați.

Limbile .NET
.NET Framework este livrat cu două limbaje de bază care sunt utilizate în mod obișnuit pentru construirea ASP.NET aplicații:
C# și VB. Aceste limbi sunt, într-o mare măsură, echivalente din punct de vedere funcțional. Microsoft a muncit din greu pentru
a elimina conflictele lingvistice din .NET Framework. Aceste bătălii încetinesc adoptarea, distrag atenția de la caracteristicile
de bază ale cadrului și îngreunează comunitatea dezvoltatorilor să rezolve problemele împreună și să împărtășească soluții.
Potrivit Microsoft, alegerea de a programa în C# în loc de VB este doar o alegere a stilului de viață și nu va afecta
performanța, interoperabilitatea, setul de caracteristici sau timpul de dezvoltare al aplicațiilor dvs. În mod surprinzător, această
afirmație ambițioasă este în esență adevărată.
.NET permite, de asemenea, altor dezvoltatori terți să lanseze limbaje care sunt la fel de bogate în caracteristici ca
C# sau VB. Aceste limbaje (care includ Eiffel, Pascal și chiar COBOL) "se fixează" în .NET Framework fără efort.
De fapt, dacă doriți să instalați un alt limbaj .NET, tot ce trebuie să faceți este să copiați compilatorul pe computer și
să adăugați o linie pentru a-l înregistra într-un fișier de configurare. De obicei, un program de instalare ar efectua

17
 CAPITOLUL LIMBA C#
2

automat acești pași pentru dvs. Odată instalat, noul compilator poate transforma creațiile de cod într-o secvență
de instrucțiuni de limbă intermediară (IL), la fel cum fac compilatoarele VB și C# cu codul VB și C#.
IL este singura limbă recunoscută de Common Language Runtime (CLR). Când creați codul pentru un
formular web ASP.NET, acesta este modificat în IL utilizând compilatorul C# (csc.exe) sau compilatorul VB
(vbc.exe). Deși puteți efectua compilarea manual, este mai probabil să lăsați ASP.NET să o gestioneze
automat atunci când este solicitată o pagină web.

Noțiuni de bază despre limba C #

Noii programatori C# sunt uneori intimidați de sintaxa ciudată a limbajului, care include caractere speciale,
cum ar fi punct și virgulă (;), acolade curbate {} și bare oblice inverse (\). Din fericire, odată ce te obișnuiești
cu C#, aceste detalii se vor topi rapid în fundal. În secțiunile următoare, veți afla despre patru principii
generale pe care trebuie să le cunoașteți despre C # înainte de a învăța orice alte concepte.

Sensibilitate la majuscule și minuscule

Unele limbi sunt sensibile la litere mari și mici, în timp ce altele nu. Java, C, C ++ și C # sunt toate exemple de limbaje
sensibile la litere mari și mici. VB nu este. Această diferență poate frustra foștii programatori VB care nu își dau seama
că cuvintele cheie, variabilele și funcțiile trebuie introduse cu cazul potrivit. De exemplu, dacă încercați să creați o
instrucțiune condițională în C# introducând If în loc de dacă, codul nu va fi recunoscut, iar compilatorul îl va semnaliza
cu o eroare atunci când încercați să construiți aplicația.
C# are, de asemenea, o preferință clară pentru cuvintele minuscule. Cuvintele cheie - cum ar fi dacă,
pentru, foreach, while, typeof și așa mai departe - sunt întotdeauna scrise cu litere mici. Când vă definiți
propriile variabile, este logic să urmați convențiile utilizate de alți programatori C# și biblioteca de clase
.NET Framework. Asta înseamnă că ar trebui să dați nume variabilelor private care încep cu o literă mică și
să dați nume variabilelor publice care încep cu o majusculă inițială. De exemplu, puteți numi o variabilă
privată MyNumber în VB și myNumber în C#. Desigur, nu trebuie să urmați acest stil atâta timp cât vă
asigurați că utilizați aceeași majusculă în mod consecvent.

Notă proiectați cod pe care alți dezvoltatori l-ar putea vedea (de exemplu, creați componente
• Dacă
pe care doriți să le vindeți altor companii), standardele de codificare sunt deosebit de importante.
Ajutorul Visual Studio conține informații despre standardele de codificare și puteți obține, de
asemenea, un rezumat excelent al celor mai bune practici în cartea albă "IDesign C# Coding
Standard" de Juval Lowy, care este disponibilă la http://www.idesign.net.

Comentarea
Comentariile sunt text descriptiv care este ignorat de compilator. C# oferă două tipuri de bază de
comentarii. Primul tip este comentariul cu o singură linie. În acest caz, comentariul începe cu două bare
oblice și continuă pentru întreaga linie curentă. Opțional, programatorii C# pot folosi și comentarii cu mai
multe linii folosind parantezele de comentarii /* și */. Acest truc este adesea folosit pentru a comenta rapid
un întreg bloc de cod. În acest fel, codul nu va fi executat, dar va rămâne în continuare în fișierul codului
sursă dacă trebuie să îl consultați sau să îl utilizați mai târziu.

18
 CAPITOLUL LIMBA C#
2

Un comentariu C# cu un singur
rând. /* Un comentariu C# cu
mai multe linii. */
C# include, de asemenea, o sintaxă de comentare bazată pe XML pe care o puteți utiliza pentru a
descrie codul într-un mod standardizat. În cazul comentariilor XML, utilizați etichete speciale care indică
dacă comentariul se aplică unei clase, metode, parametru și așa mai departe. Iată un exemplu de
comentariu care oferă un rezumat pentru o întreagă aplicație:
<rezumat> /// Această aplicație oferă pagini
web /// pentru site-ul meu de comerț
electronic. </rezumat>

Comentariile XML încep întotdeauna cu trei bare oblice. Avantajul comentariilor bazate pe XML este că
instrumentele automate (inclusiv Visual Studio) pot extrage comentariile din cod și le pot utiliza pentru a
construi referințe de ajutor și alte tipuri de documentație. Pentru mai multe informații despre comentariile
XML, puteți consulta un articol MSDN excelent la http://msdn.microsoft.com/magazine/cc302121.aspx. Și
dacă sunteți nou în sintaxa XML în general, veți afla despre aceasta în detaliu în capitolul 18.

Rezilierea declarației
C# folosește punct și virgulă (;) ca caracter de terminare a declarației. Fiecare instrucțiune din codul C# trebuie să se
termine cu punct și virgulă, cu excepția cazului în care definiți o structură bloc, cum ar fi o metodă, o instrucțiune
condițională sau o construcție în buclă. Prin omiterea acestui punct și virgulă, puteți împărți cu ușurință o declarație de
cod pe mai multe linii fizice. Trebuie doar să vă amintiți să puneți punct și virgulă la sfârșitul ultimei linii pentru a încheia
afirmația.
Următorul fragment de cod demonstrează patru moduri echivalente de a efectua aceeași operație
(adunând trei numere împreună):
O instrucțiune de cod pe o singură linie.
myValue = myValue1 + myValue2 + myValue3;
O instrucțiune de cod împărțită pe două linii.
myValue = myValue1 + myValue2 + myValue3;

O instrucțiune de cod împărțită pe trei linii.

myValue = myValue1 + myValue2 + myValue3;

Două instrucțiuni de cod la rând.

myValue = myValue1 + myValue2;
myValue = myValue + myValue3;
După cum puteți vedea în acest exemplu, C# vă oferă o gamă largă de libertate pentru a vă împărți
declarația în orice mod doriți. Regula generală este să faceți codul cât mai lizibil posibil. Astfel, dacă aveți o
afirmație lungă, răspândiți-o pe mai multe rânduri, astfel încât să fie mai ușor de citit. Pe de altă parte, dacă
aveți o instrucțiune de cod complexă care efectuează mai multe operații simultan, puteți răspândi
instrucțiunea pe mai multe linii sau puteți separa logica în mai multe instrucțiuni de cod pentru a o face mai
clară.
 CAPITOLUL LIMBA C#
2

Blocuri
Limbajele C#, Java și C se bazează foarte mult pe acolade ondulate - paranteze cu ceva mai multă atitudine: {}. Puteți
găsi bretelele ondulate în dreapta majorității tastaturilor (lângă tasta P); Ei împart o cheie cu parantezele pătrate: [].

Aparatele dentare ondulate grupează mai multe instrucțiuni de cod împreună. De obicei, motivul pentru care
veți dori să grupați instrucțiunile de cod este că doriți ca acestea să fie repetate într-o buclă, executate
condiționat sau grupate într-o funcție. Veți vedea toate aceste tehnici în acest capitol. Dar, în fiecare caz,
aparatele dentare ondulate joacă același rol, ceea ce face C# mai simplu și mai concis decât alte limbaje
care au nevoie de o sintaxă diferită pentru fiecare tip de structură bloc.
{ // Declarațiile de cod merg aici. }

Variabile și tipuri de date

Ca și în cazul tuturor limbajelor de programare, țineți evidența datelor în C# folosind variabile. Variabilele pot
stoca numere, text, date și ore și pot chiar indica obiecte cu drepturi depline.
Când declarați o variabilă, îi dați un nume și specificați tipul de date pe care le va stoca. Pentru a declara
o variabilă locală, începeți linia cu tipul de date, urmat de numele pe care doriți să îl utilizați. Un punct și
virgulă final încheie declarația.
Declarați o variabilă întreagă numită errorCode. int
errorCode;

Declarați o variabilă șir numită myName. șir

myName;

Notă Rețineți,
• Numele nu suntînechivalente!
C# numele Pentru
variabilelor și
a încurca și mai mult lucrurile, programatorii C#
folosesc uneori acest fapt în avantajul lor - folosind mai multe variabile care au același ame,
dar cu majuscule diferite. Această tehnică este uneori utilă atunci când se face distincția între
variabilele private și publice dintr-o clasă (așa cum s-a demonstrat în capitolul 3), dar ar trebui
să o evitați dacă există vreo posibilitate de confuzie.

Fiecare limbaj .NET utilizează aceleași tipuri de date variabile. Limbi diferite pot furniza nume ușor diferite (de
exemplu, un întreg VB este același cu un C# int), dar CLR nu face nicio distincție - de fapt, acestea sunt doar
două nume diferite pentru același tip de date de bază (în acest caz, este System.Int32). Acest design permite
integrarea profundă a limbajului. Deoarece limbile partajează aceleași tipuri de date de bază, puteți utiliza cu
ușurință obiecte scrise într-o limbă .NET într-o aplicație scrisă într-o altă limbă .NET. Nu sunt necesare
conversii de tip de date.

20
 CAPITOLUL LIMBA C#
2

Notă pentru care toate limbajele .NET au aceleași tipuri de date este că toate aderă la
• Motivul
common type system (CTS), un standard ECMA proiectat de Microsoft, care stabilește regulile de
bază pe care toate limbile .NET trebuie să le respecte atunci când tratează date.

Pentru a crea acest sistem comun de tip de date, Microsoft a trebuit să elimine multe dintre inconsecvențele
care existau între VBScript, VB 6, C ++ și alte limbi. Soluția a fost crearea unui set de tipuri de date de bază,
care sunt furnizate în biblioteca de clase .NET. Tabelul 2-1 listează cele mai importante tipuri de date de
bază.
Tabelul 2-1. Tipuri de date comune

C# Nume Nume VB Numele tipului .NET Conţine

byte Byte Byte Un număr întreg de la 0 la 255.

scurt Scurt Int16 Un număr întreg de la –32.768 la 32.767.

Int Întreg Int32 Un număr întreg de la –2.147.483.648 la 2.147.483.647.

lung Lung Int64 Un număr întreg de la aproximativ –9.2e18 la 9.2e18.

pluti Singur Singur Un număr în virgulă mobilă cu o singură precizie de

la aproximativ –3.4e38 la 3.4e38 (pentru numere
mari) sau –1.5e-45 la 1.5e-45 (pentru numere
fracționare mici).
dublu Dublu Dublu Un număr în virgulă mobilă cu dublă precizie de
la aproximativ –1,8e308 la 1,8e308 (pentru
numere mari) sau –5,0e-324 la 5,0e-324 (pentru
numere fracționare mici).
zecimală Zecimală Zecimală Un număr fracționat cu punct fix pe 128 de biți
care acceptă până la 28 de cifre semnificative.

Char Char Char A singur caracter Unicode.

șir Șir Șir A serie de caractere Unicode de lungime variabilă.

Bool Boolean Boolean A valoare adevărată sau falsă.

* Dată DatăOră Reprezintă orice dată și oră de la 12:00:00 AM, 1 ianuarie a

anului 1 în calendarul gregorian, până la 11:59:59 PM, 31
decembrie a anului 9999. Valorile de timp pot rezolva
valorile în trepte de 100 nanosecunde. Intern, acest tip de
date este stocat ca întreg pe 64 de biți.

21
 CAPITOLUL LIMBA C#
2

C# Nume Nume VB Numele tipului .NET Conţine

* * Interval de timp Reprezintă o perioadă de timp, ca în zece secunde

sau trei zile. Cel mai mic interval posibil este de 1
bifă (100 nanosecunde).
obiect Obiect Obiect Clasa de bază supremă a tuturor tipurilor .NET.
Poate conține orice tip de date sau obiect.

* Dacă limba nu furnizează un alias pentru un anumit tip, trebuie să utilizați numele tipului .NET.

De asemenea, aveți posibilitatea să declarați o variabilă utilizând numele tipului din biblioteca de clase
.NET. Această abordare produce variabile identice. Este, de asemenea, o cerință atunci când tipul de date
nu are un alias încorporat în limbă. De exemplu, puteți rescrie exemplul anterior care a utilizat numele
tipurilor de date C# cu acest fragment de cod care utilizează numele bibliotecilor de clase:
Cod de eroare System.Int32; System.String myName;

Acest fragment de cod utilizează nume de tip complet calificate care indică faptul că tipul Int32 și tipul
String se găsesc în spațiul de nume Sistem (împreună cu toate tipurile fundamentale). În capitolul 3, veți
afla mai detaliat despre tipuri și spații de nume.

CE ESTE ÎNTR-UN NUME? NU TIPUL DE DATE!

Veți observa că exemplele anterioare nu utilizează prefixe variabile. Mulți programatori vechi C / C ++ și VB
au obiceiul de a adăuga câteva caractere la începutul unui nume de variabilă pentru a indica tipul său de
date. În .NET, această practică este descurajată, deoarece tipurile de date pot fi utilizate într-o gamă mult
mai flexibilă de moduri fără nicio problemă, iar majoritatea variabilelor conțin oricum referințe la obiecte
complete. În această carte, prefixele variabilelor nu sunt utilizate, cu excepția controalelor web, unde ajută
la distingerea între liste, casete de text, butoane și alte elemente comune ale interfeței cu utilizatorul. În
propriile programe, ar trebui să urmați un standard consecvent (de obicei la nivel de companie) care poate
sau nu să adopte un sistem de prefixe variabile.

Atribuire și inițializatoare
După ce ați declarat variabila, îi puteți atribui în mod liber valori, atât timp cât aceste valori au tipul de date
corect. Iată codul care arată acest proces în doi pași:

Declarați variabilele. int

errorCode; șir myName;

Atribuiți valori. cod de

eroare = 10; myName
= "Matei";
De asemenea, puteți atribui o valoare unei variabile din aceeași linie pe care o declarați. Acest
exemplu comprimă patru linii de cod în două:

22
 CAPITOLUL LIMBA C#
2

int errorCode = 10; șir myName

= "Matei";

C# vă protejează de erori, restricționându-vă să utilizați variabile neinițializate. De exemplu, următorul cod

provoacă o eroare atunci când încercați să îl compilați:

numărul int; Numărul este neinițializat. număr = număr + 1; Acest lucru

provoacă o eroare de compilare.

Modul corect de a scrie acest cod este de a inițializa în mod explicit variabila numerică la o valoare
corespunzătoare, cum ar fi 0, înainte de a o utiliza:

numărul int = 0; Numărul conține acum 0. număr = număr +

1; Numărul conține acum 1.

C# se ocupă, de asemenea, strict de tipurile de date. De exemplu, următoarea instrucțiune de cod nu

va funcționa așa cum este scrisă:
zecimal myZecimal = 14,5;
Problema este că literalul 14.5 este interpretat automat ca o dublă și nu puteți converti o dublă într-o
zecimală fără a utiliza sintaxa de turnare, care este descrisă mai târziu în acest capitol. Pentru a rezolva
această problemă, C# definește câteva caractere speciale pe care le puteți adăuga la valori literale pentru a
indica tipul lor de date, astfel încât să nu fie necesară nicio conversie. Aceste caractere sunt următoarele:
• M (zecimal)
• D (dublu)
• F (plutitor)
• L (lung)
De exemplu, puteți rescrie exemplul anterior utilizând indicatorul zecimal după cum urmează:

zecimal myDecimal = 14,5M;

• MNotă
esteÎnutilizat,
acest exemplu,
dar puteți oînlocui
majusculă
un m minuscul în locul său. Indicatorii tipului de date sunt unul
dintre puținele detalii care nu sunt sensibile la litere mari și mici în C#.

Interesant este că, dacă utilizați un cod ca acesta pentru a declara și inițializa variabila într-un singur pas și
dacă compilatorul C# poate determina tipul de date corect pe baza valorii pe care o utilizați, nu este
necesar să specificați tipul de date. În schimb, puteți utiliza cuvântul cheie var universal în locul tipului de
date. Asta înseamnă că linia anterioară de cod este echivalentă cu aceasta:
var myDecimal = 14,5M;
Aici, compilatorul își dă seama că un tip de date zecimal este cea mai potrivită alegere pentru variabila myDecimal și
utilizează automat acel tip de date. Nu există nicio diferență de performanță. Variabila myDecimal pe care o creați utilizând
un tip de date dedus se comportă exact în același mod ca o variabilă myDecimal creată cu un tip de date explicit. De fapt,

23
 CAPITOLUL LIMBA C#
2

codul de nivel scăzut pe care compilatorul îl generează este identic. Singura diferență este că cuvântul cheie var
salvează unele tastări.
Mulți programatori C# se simt neliniștiți cu cuvântul cheie var, deoarece face codul mai puțin clar. Cu toate
acestea, cuvântul cheie var este o comandă rapidă mai utilă atunci când creați obiecte, așa cum veți vedea în
capitolul următor.

Corzi și personaje scăpate

C# tratează textul puțin diferit față de alte limbi, cum ar fi VB. Acesta interpretează orice bară oblică inversă
încorporată (\) ca începutul unei secvențe speciale de evadare a caracterelor. De exemplu, \n înseamnă
adăugați o nouă linie (întoarcerea căruciorului). Cele mai utile caractere literale sunt următoarele:
• \" (citat dublu)
• \n (linie nouă)
• \t (filă orizontală)
• \\ (bară oblică înapoi)
De asemenea, puteți introduce un caracter special pe baza codului său hexazecimal utilizând sintaxa \x123.
Aceasta inserează un singur caracter cu valoarea hexazecimală 123.
Rețineți că, pentru a specifica caracterul bară oblică inversă reală (de exemplu, într-un nume de director),
aveți nevoie de două bare oblice. Iată un exemplu:

O variabilă C# care deține calea

// c:\MyApp\MyFiles. cale =
"c:\\MyApp\\MyFiles";
Alternativ, puteți dezactiva C# escaping precedând un șir cu un simbol @, așa cum se arată aici:
cale = @"c:\MyApp\MyFiles";

Matrice
Matricele vă permit să stocați o serie de valori care au același tip de date. Fiecare valoare individuală din matrice este
accesată utilizând unul sau mai multe numere de index. Este adesea convenabil să vă imaginați matricele ca liste de
date (dacă matricea are o dimensiune) sau grile de date (dacă matricea are două dimensiuni). De obicei, matricele sunt
dispuse contiguu în memorie.
Toate matricele încep de la o limită inferioară fixă de 0. Această regulă nu are excepții. Când creați o matrice în
C#, specificați numărul de elemente. Deoarece numărătoarea începe de la 0, cel mai mare indice este de fapt cu
unul mai mic decât numărul de elemente. (Cu alte cuvinte, dacă aveți trei elemente, cel mai mare indice este 2.)

Creați o matrice cu patru șiruri (de la indicele 0 la indicele 3). Trebuie să

inițializați matricea cu noul cuvânt cheie // pentru ao utiliza.

string[] stringArray = șir nou[4];

Creați o matrice de grilă 2x4 (cu un total de opt numere întregi). int[,] intArray
= nou int[2, 4];

În mod implicit, dacă matricea include tipuri de date simple, toate sunt inițializate la valorile implicite (0 sau false), în funcție de
tipul de număr: sau o variabilă booleană. Dar dacă matricea este formată din șiruri sau alt tip de obiect, este inițializată cu

24
 CAPITOLUL LIMBA C#
2

referințe nule. (Pentru o discuție mai cuprinzătoare care subliniază diferența dintre tipurile de valori simple și tipurile de referință,
vezi capitolul 3.) De asemenea, puteți completa o matrice cu date în același timp în care o creați. În acest caz, nu este necesar
să specificați în mod explicit numărul de elemente, deoarece .NET îl poate determina automat:

Creați o matrice cu patru șiruri, câte unul pentru fiecare număr de la 1 la 4. string[]
stringArray = {"1", "2", "3", "4"};

Aceeași tehnică funcționează și pentru matricele multidimensionale, cu excepția faptului că sunt

necesare două seturi de paranteze curbate:
Creați o matrice 4x2 (o grilă cu patru rânduri și două coloane). int[,] intArray =
{{1, 2}, {3, 4}, {5, 6}, {7, 8}};

Figura 2-1 arată cum arată această matrice în memorie.

Figura 2-1. Un eșantion de matrice de numere întregi

Pentru a accesa un element dintr-o matrice, specificați numărul index corespunzător între paranteze
pătrate: []. Indicii matricei sunt întotdeauna bazați pe zero. Asta înseamnă că myArray[0] accesează prima
celulă dintr-o matrice unidimensională, myArray[1] accesează a doua celulă și așa mai departe.
int[] intArray = {1, 2, 3, 4}; int element = stringArray[2]; Element este acum
setat la 3.

Într-o matrice bidimensională, aveți nevoie de două numere de index.

25
 CAPITOLUL LIMBA C#
2

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

Accesați valoarea din rândul 0 (primul rând), coloana 1 (a doua coloană).

element int = intArray[0, 1]; Element este acum setat la 2.

Matricea
Matricele C# nu acceptă redimensionarea. Aceasta înseamnă că, odată ce creați o matrice, nu îi puteți
modifica dimensiunea. În schimb, ar trebui să creați o nouă matrice cu noua dimensiune și să copiați valorile
din vechea matrice în cea nouă, ceea ce ar fi un proces obositor. Cu toate acestea, dacă aveți nevoie de o
listă de tip matrice dinamică, puteți utiliza una dintre clasele de colecție furnizate tuturor limbilor .NET prin
biblioteca de clase .NET. Una dintre cele mai simple clase de colectare pe care le oferă .NET este ArrayList,
care permite întotdeauna redimensionarea dinamică. Iată un fragment de cod C# care utilizează un ArrayList:
Creați un obiect ArrayList. Este o colecție, nu o matrice, // deci sintaxa este
ușor diferită.
ArrayList dynamicList = nou ArrayList();

Adăugați mai multe șiruri la listă.

ArrayList nu este puternic tastat, astfel încât puteți adăuga orice tip de date // deși
este mai simplu dacă stocați un singur tip de obiect // în orice colecție dată.

dynamicList.Add ("unul");
dynamicList.Add ("două");
dynamicList.Add ("trei");
Recuperați primul șir. Observați că obiectul trebuie convertit într-un șir //, deoarece nu
există nicio modalitate ca .NET să fie sigur ce este. element șir =
Convert.ToString(dynamicList[0]);
Veți afla mai multe despre ArrayList și alte colecții în capitolul 3.

• ÎnSfat
multe cazuri, este mai ușor să evitați problemele de numărare și să utilizați o colecție completă,
mai degrabă decât o matrice. Colecțiile sunt, în general, mai potrivite pentru programarea modernă
orientată pe obiecte și sunt utilizate pe scară largă în ASP.NET. Biblioteca de clase .NET oferă multe
tipuri de clase de colecții, inclusiv colecții simple, liste sortate, liste indexate cu chei (dicționare) și
cozi. Veți vedea exemple de colecții pe parcursul acestei cărți.

Enumerări
O enumerare este un grup de constante înrudite, fiecare având un nume descriptiv. Fiecare valoare dintr-o
enumerare corespunde unui întreg prestabilit. Cu toate acestea, în codul dvs., puteți face referire la o valoare
enumerată după nume, ceea ce face codul mai clar și ajută la prevenirea erorilor. De exemplu, este mult mai
simplu să setați marginea unei etichete la valoarea enumerată BorderStyle.Dashed decât la constanta
numerică obscură 3. În acest caz, Dashed este o valoare din enumerarea BorderStyle și reprezintă numărul
3.

26
 CAPITOLUL LIMBA C#
2

Notă:
• are de Doar pentru
fapt mai multade
menține viața
un sens. interesantă,
După cum estecuvântul enumerare
descris în această secțiune, enumerările sunt
seturi de valori constante. Cu toate acestea, programatorii vorbesc adesea despre procesul de
enumerare, ceea ce înseamnă a bucla sau a repeta peste o colecție. De exemplu, este obișnuit
să vorbim despre enumerarea tuturor caracterelor unui șir (ceea ce înseamnă buclă prin șir și
examinarea fiecărui caracter într-o trecere separată).

Iată un exemplu de enumerare care definește diferite tipuri de utilizatori:

Definiți un tip de enumerare numit UserType cu trei valori posibile. enum UserType
{ admin, oaspete, invalid }

Acum puteți utiliza enumerarea UserType ca tip de date special care este restricționat la una dintre cele trei
valori posibile. Atribuiți sau comparați valoarea enumerată utilizând notația punct prezentată în exemplul
următor:
Creați o valoare nouă și setați-o egală cu constanta UserType.Admin. UserType
newUserType = UserType.Admin;

Pe plan intern, enumerările sunt menținute ca numere. În exemplul precedent, 0 este atribuit automat
Administratorului, 1 Vizitatorului și 2 Nevalid. Puteți seta un număr direct într-o variabilă de enumerare, deși acest
lucru poate duce la o eroare nedetectată dacă utilizați un număr care nu corespunde uneia dintre valorile definite.

În mod clar, enumerările creează un cod mai lizibil. De asemenea, simplifică codificarea, deoarece odată ce
tastați numele tipului de enumerare (ErrorCode) și adăugați punctul (.), Visual Studio va afișa o listă de valori
posibile folosind IntelliSense.

Sfat
• Enumerările sunt utilizate pe scară largă în .NET. Nu va trebui să creați propriile enumerări
pentru a le utiliza în ASP.NET aplicații, cu excepția cazului în care proiectați propriile componente.
Cu toate acestea, conceptul de valori enumerate este extrem de important, deoarece biblioteca de
clasă .NET îl folosește pe scară largă. De exemplu, setați culori, stiluri de bordură, aliniere și
diverse alte stiluri de control Web utilizând enumerările furnizate în biblioteca de clase .NET.

Operațiuni variabile
Puteți utiliza toate tipurile standard de operații variabile în C#. Când lucrați cu numere, puteți utiliza diferite
simboluri matematice, așa cum sunt enumerate în tabelul 2-2. C# urmează ordinea convențională a
operațiilor, efectuând mai întâi exponențierea, urmată de înmulțire și împărțire și apoi adunare și scădere.
De asemenea, puteți controla ordinea grupând subexpresiile între paranteze:

27
 CAPITOLUL LIMBA C#
2

numărul int;

număr = 4 + 2 * 3;
Numărul va fi 10.

număr = (4 + 2) * 3; Numărul va fi 18.

Tabelul 2-2. Operații aritmetice

Operator Descriere Exemplu

+ Adăugare 1+ 1 = 2

– 5- 2 = 3

* 2 * 5 = 10
Descărcați de la Wow! eBook <www.wowebook.com>

/Divizie 5,0 / 2 = 2,5

% Rămâne restul după împărțirea numerelor întregi 7% 3 = 1

Diviziunea poate provoca uneori confuzie în C#. Dacă împărțiți un întreg la un alt întreg, C# efectuează
împărțirea întregului. Aceasta înseamnă că elimină automat partea fracționată a răspunsului și
returnează întreaga parte ca întreg. De exemplu, dacă împărțiți 5 la 2, veți ajunge la 2 în loc de 2,5.
Soluția este să indicați în mod explicit că unul dintre numerele dvs. este o valoare fracționată. De exemplu, dacă
înlocuiți 5 cu 5M, C# va trata 5 ca zecimal. Dacă înlocuiți 5 cu 5.0, C# îl va trata ca pe o dublă. În orice caz, divizia va
returna valoarea așteptată de 2,5. Desigur, această problemă nu apare foarte des în codul din lumea reală, deoarece
atunci împărțiți de obicei o variabilă la alta. Atâta timp cât variabilele tale nu sunt întregi, nu contează ce număr conțin.

Operatorii din tabelul 2-2 sunt proiectați pentru manipularea numerelor. Cu toate acestea, C# vă permite, de
asemenea, să utilizați operatorul de adunare (+) pentru a uni două șiruri:

Uniți trei șiruri împreună. myName =

prenume + " " + nume;

În plus, C# oferă, de asemenea, operatori speciali de atribuire prescurtată. Iată câteva exemple:

Adăugați 10 la myValue. Aceasta este aceeași cu myValue = myValue +

10; myValue += 10;

Multiplu myValue cu 3. Aceasta este aceeași cu myValue = myValue * 3;

myValue *= 3;

Împărțiți myValue la 12. Aceasta este aceeași cu myValue = myValue / 12; myValue /= 12;

28
 CAPITOLUL LIMBA C#
2

Matematică avansată
În trecut, fiecare limbă a avut propriul set de cuvinte cheie pentru operații matematice comune, cum ar fi rotunjirea și
trigonometria. În limbile .NET, multe dintre aceste cuvinte cheie rămân. Cu toate acestea, puteți utiliza, de asemenea, o
clasă de matematică centralizată care face parte din .NET Framework. Acest lucru are efectul secundar plăcut de a vă
asigura că codul pe care îl utilizați pentru a efectua operații matematice poate fi ușor tradus în declarații echivalente în
orice limbaj .NET cu agitație minimă.
Pentru a utiliza operațiile matematice, invocați metodele clasei System.Math. Aceste metode sunt statice, ceea ce
înseamnă că sunt întotdeauna disponibile și gata de utilizare. (Următorul capitol explorează mai detaliat diferența dintre
membrii statici și cei ai instanței.)
Următorul fragment de cod afișează câteva exemple de calcule pe care le puteți efectua cu clasa de
matematică:

dublu myValue; myValue = Math.Sqrt(81); myValue = 9.0 myValue =

Math.Round(42.889, 2); myValue = 42.89 myValue = Math.Abs(-10);
myValue = 10.0 myValue = Math.Log(24.212); myValue = 3.18.. (și așa mai
departe) myValue = Math.PI; myValue = 3.14.. (și așa mai departe)

Caracteristicile clasei de matematică sunt prea numeroase pentru a fi enumerate aici în întregime.
Exemplele precedente arată câteva operații numerice comune. Pentru mai multe informații despre funcțiile
trigonometrice și logaritmice disponibile, consultați referința Ajutor Visual Studio pentru clasa de
matematică.

Tastați conversii
Conversia informațiilor de la un tip de date la altul este o sarcină de programare destul de comună. De exemplu, puteți
regăsi introducerea textului pentru un utilizator care conține numărul pe care doriți să îl utilizați pentru un calcul. Sau
poate fi necesar să luați o valoare calculată și să o transformați în text pe care îl puteți afișa într-o pagină web.

Conversiile sunt de două tipuri: lărgire și îngustare. Extinderea conversiilor reușește întotdeauna. De
exemplu, puteți converti întotdeauna un întreg pe 32 de biți într-un întreg pe 64 de biți. Nu veți avea nevoie
de niciun cod special:
int mySmallValue;
lung myLargeValue;

Obțineți cea mai mare valoare posibilă care poate fi stocată ca număr întreg pe 32 de
biți. .NET furnizează o constantă numită Int32.MaxValue care furnizează acest număr.
mySmallValue = Int32.MaxValue;
Acest lucru reușește întotdeauna. Indiferent cât de mare este
mySmallValue, // poate fi conținut în myLargeValue.
myLargeValue = mySmallValue;
Pe de altă parte, restrângerea conversiilor poate sau nu să reușească, în funcție de date. În cazul în care efectuați conversia
unui număr întreg pe 32 de biți într-un număr întreg pe 16 biți, este posibil să întâlniți o eroare dacă numărul pe 32 de biți este
mai mare decât valoarea maximă care poate fi stocată în tipul de date pe 16 biți. Toate conversiile înguste trebuie efectuate în
mod explicit. C# folosește o metodă elegantă pentru conversia explicită a tipului. Pentru a converti o variabilă, trebuie doar să
specificați textul între paranteze înainte de expresia pe care o convertiți. Următorul cod arată cum se schimbă un număr întreg

29
 CAPITOLUL LIMBA C#
2

pe 32 de biți într-un număr întreg pe 16 biți:

număr int32 = 1000;

numărătoare scurtă16;

Convertiți întregul pe 32 de biți într-un întreg pe 16 biți.

Dacă count32 este prea mare pentru a încăpea, .NET va elimina unele dintre
informațiile // de care aveți nevoie, iar numărul rezultat va fi incorect. count16 =
numărătoarea (scurtă)32;

Dacă nu utilizați o proiecție explicită atunci când încercați să efectuați o conversie îngustă, veți primi o
eroare atunci când încercați să compilați codul. Cu toate acestea, chiar dacă efectuați o conversie
explicită, ați putea totuși să întâmpinați o problemă. De exemplu, luați în considerare codul afișat aici, care
provoacă o depășire:
int mySmallValue;
lung myLargeValue;

myLargeValue = Int32.MaxValue;
myLargeValue++;
Acest lucru va părea să reușească (nu va exista o eroare la momentul rulării), // dar
datele dvs. vor fi incorecte deoarece mySmallValue nu poate deține o valoare atât
de mare.
mySmallValue = (int)myLargeValue;

Limbile .NET diferă în modul în care tratează această problemă. În VB, veți primi întotdeauna o eroare de
execuție pe care trebuie să o interceptați și la care trebuie să răspundeți. Cu toate acestea, în C#, veți ajunge
pur și simplu cu date incorecte în mySmallValue. Pentru a evita această problemă, ar trebui fie să verificați
dacă datele nu sunt prea mari înainte de a încerca o conversie îngustă (ceea ce este întotdeauna o idee
bună), fie să utilizați un bloc verificat. Blocul verificat permite verificarea depășirii pentru o porțiune de cod.
Dacă apare o depășire, veți primi automat o eroare, la fel ca în VB:
bifat { // Acest lucru va determina aruncarea unei
excepții. mySmallValue = (int)myLargeValue; }

• Sfat De obicei, nu veți utiliza blocul verificat, deoarece este ineficient. Blocatul verificat
surprinde problema (prevenind o eroare de date), dar aruncă o excepție, pe care trebuie să o
gestionați folosind codul de manipulare a erorilor, așa cum se explică în capitolul 7. În general,
este mai ușor doar să efectuați propriile verificări cu numere potențial nevalide înainte de a încerca
o operațiune. Cu toate acestea, blocul verificat este util într-o singură situație - depanarea. În acest
fel, puteți detecta erori neașteptate în timp ce încă testați aplicația și le puteți rezolva imediat.

În C#, nu puteți utiliza proiectarea pentru a converti numerele în șiruri de caractere sau invers. În acest caz, datele nu

30
 CAPITOLUL LIMBA C#
2

sunt doar mutate de la o variabilă la alta - trebuie traduse într-un format complet diferit. Din fericire, .NET are o serie de
soluții pentru efectuarea conversiilor avansate. O opțiune este utilizarea metodelor statice ale clasei Conversie, care
acceptă multe tipuri de date comune, cum ar fi șiruri, date și numere.

string countString = "10";

Convertiți șirul "10" la valoarea numerică 10. int count =

Convert.ToInt32(countString);
Convertiți valoarea numerică 10 în șirul "10". countString =
Convert.ToString(count);
Al doilea pas (transformarea unui număr într-un șir) va funcționa întotdeauna. Primul pas (transformarea unui șir într-un
număr) nu va funcționa dacă șirul conține litere sau alte caractere non-numerice, caz în care va apărea o eroare.
Capitolul 7 descrie modul în care puteți utiliza gestionarea erorilor pentru a detecta și neutraliza acest tip de problemă.

Clasa Conversie este o soluție universală bună, dar veți găsi și alte metode statice care pot face treaba,
dacă săpați în biblioteca de clase .NET. Următorul cod utilizează metoda statică Int32.Parse() pentru a
efectua aceeași activitate:
număr int; string countString =
"10";
Convertiți șirul "10" la valoarea numerică 10. count =
Int32.Parse(countString);

Veți găsi, de asemenea, că puteți utiliza metode obiect pentru a efectua unele conversii puțin mai
elegant. Următoarea secțiune demonstrează această abordare cu metoda ToString().

Manipulare bazată pe obiecte

.NET este orientat obiect către nucleu. De fapt, chiar și variabilele obișnuite sunt într-adevăr obiecte cu drepturi depline
deghizate. Aceasta înseamnă că tipurile de date comune au inteligența încorporată pentru a gestiona operațiile de bază
(cum ar fi numărarea numărului de caractere dintr-un șir). Chiar mai bine, înseamnă că puteți manipula șiruri, date și
numere în același mod în C # și în VB.
De exemplu, fiecare tip din biblioteca de clase .NET include o metodă ToString(). Implementarea implicită a
acestei metode returnează numele clasei. În variabilele simple, se returnează un rezultat mai util:
reprezentarea șirului variabilei date. Următorul fragment de cod demonstrează cum se utilizează metoda
ToString() cu un număr întreg:
șir myString; int
myInteger = 100;
Conversia unui număr într-un șir. myString va avea conținutul "100". myString =
myInteger.ToString();
Pentru a înțelege acest exemplu, trebuie să vă amintiți că toate variabilele int se bazează pe tipul Int32 din biblioteca de
clasă .NET. Metoda ToString() este încorporată în clasa Int32, deci este disponibilă atunci când utilizați un număr întreg în
orice limbă.
Următoarele câteva secțiuni explorează mai detaliat bazele orientate pe obiecte ale tipurilor de
date .NET.

31
 CAPITOLUL LIMBA C#
2

Tipul șirului
Unul dintre cele mai bune exemple despre modul în care membrii clasei pot înlocui funcțiile încorporate se găsește
cu șiruri de caractere. În trecut, fiecare limbă și-a definit propriile funcții specializate pentru manipularea șirurilor. Cu
toate acestea, în .NET utilizați metodele clasei String, care asigură coerența între toate limbile .NET.

Următorul fragment de cod prezintă mai multe moduri de a manipula un șir folosind natura obiectului său:

string myString = "Acesta este un șir de test "; myString = myString.Trim(); =

"Acesta este un șir de test" myString = myString.Substring(0, 4); = "Acest"
myString = myString.ToUpper(); = "ACEST" myString = myString.Replace("IS",
"AT"); = "ACELA"

int length = myString.Length; =4

Primele câteva afirmații utilizează metode încorporate, cum ar fi Trim(), Substring(), ToUpper() și Replace().
Aceste metode generează șiruri noi și fiecare dintre aceste afirmații înlocuiește myString-ul curent cu noul
obiect șir. Instrucțiunea finală utilizează o proprietate Lungime predefinită, care returnează un număr întreg
care reprezintă numărul de caractere din șir.

Sfat: O metodă este doar o procedură care este cablată într-un obiect. O proprietate este similară cu o variabilă - este o modalitate
•
pentru a accesa o bucată de date asociată cu un obiect. Veți afla mai multe despre metode și proprietăți în capitolul
următor.

Rețineți că metoda Substring() necesită un decalaj de pornire și o lungime de caracter. Șirurile utilizează numărarea
bazată pe zero. Aceasta înseamnă că prima literă este în poziția 0, a doua literă este în poziția 1 și așa mai departe.
Veți găsi acest standard de numărare bazată pe zero în .NET Framework din motive de consecvență. L-ați văzut deja la
lucru cu matricele.
Puteți utiliza chiar și metodele de șir succesiv într-o singură linie (destul de urâtă):

myString = myString.Trim(). Subșir(0, 4). ToUpper(). Înlocuire("IS", "AT");

Sau, pentru a face viața mai interesantă, puteți utiliza metodele șir pe șiruri literale la fel de ușor ca
variabilele șirului:
myString = "salut". ToUpper(); Setează myString la "HELLO"
Tabelul 2-3 listează câțiva membri utili ai clasei System.String.

32
 CAPITOLUL LIMBA C#
2

Tabelul 2-3. Membri de șiruri utile1

Membru Descriere
Lungime Returnează numărul de caractere din șir (ca întreg).

ToUpper() și ToLower() Returnează o copie a șirului cu toate caracterele transformate în

caractere majuscule sau minuscule.
Trim(), TrimEnd() și TrimStart() Elimină spațiile sau alte caractere de la fiecare capăt (sau de la
ambele capete) ale unui șir.
PadLeft() și PadRight() Adaugă caracterul specificat în partea corespunzătoare a unui șir
de câte ori este necesar pentru a face lungimea totală a șirului
egală cu numărul specificat. De exemplu, "Bună". PadLeft(5, '@')
returnează șirul @@@Hi.
Insert() Pune un alt șir într-un șir într-o poziție de index specificată (bazată
pe zero). De exemplu, Insert(1, "pre") adaugă șirul pre după
primul caracter al șirului curent.
Eliminare() Elimină un număr specificat de caractere dintr-o poziție specificată.
De exemplu, Eliminare(0, 1) elimină primul caracter.
Înlocuire() Înlocuiește un subșir specificat cu un alt șir. De exemplu,
Replace("a", "b") schimbă toate caracterele dintr-un șir în b
caractere.
Subșir() Extrage o porțiune dintr-un șir de lungimea specificată în locația
specificată (ca șir nou). De exemplu, Substring(0, 2) preia primele
două caractere.
StartsWith() și EndsWith() Determină dacă un șir începe sau se termină cu un subșir
specificat. De exemplu, StartsWith("pre") va returna fie true, fie
false, în funcție de faptul dacă șirul începe cu literele pre cu litere
mici.
IndexOf() și LastIndexOf() Găsește poziția zero a unui subșir dintr-un șir. Aceasta returnează doar
primul meci și poate începe la sfârșit sau la început. De asemenea,
puteți utiliza versiuni supraîncărcate ale acestor metode care acceptă
un parametru care specifică poziția pentru a începe căutarea.
Scindare() Împarte un șir într-o matrice de subșiruri delimitate de un anumit
subșir. De exemplu, cu Split(".") puteți tăia un paragraf într-o matrice
de șiruri de propoziții.
Alăturați-vă() Fuzionează o serie de șiruri într-un șir nou. De asemenea, trebuie să
specificați separatorul care va fi inserat între fiecare element (sau să
utilizați un șir gol dacă nu doriți niciun separator).
1
Din punct de vedere tehnic, șirurile de caractere nu pot fi modificate niciodată. Toate metodele de șir care par să
modifice un șir returnează de fapt o copie a șirului care are modificările.

33
 CAPITOLUL LIMBA C#
2

Tipurile DateTime și TimeSpan

Tipurile de date DateTime și TimeSpan au, de asemenea, metode și proprietăți predefinite. Acești
membri ai clasei vă permit să îndepliniți trei sarcini utile:
• Extrageți o parte dintr-un DateTime (de exemplu, doar anul) sau convertiți un
TimeSpan într-o anumită reprezentare (cum ar fi numărul total de zile sau numărul
total de minute)
• Efectuați cu ușurință calcule de date
• Determinați data și ora curentă și alte informații (cum ar fi ziua săptămânii sau dacă
data apare într-un an bisect)
De exemplu, următorul bloc de cod creează un obiect DateTime, îl setează la data și ora curente și adaugă
un număr de zile. Apoi creează un șir care indică anul în care se încadrează noua dată (de exemplu, 2010).

DateTime myDate = DateTime.Now; myDate =

myDate.AddDays(100); string dateString =
myDate.Year.ToString();
Următorul exemplu arată cum puteți utiliza un obiect Interval de timp pentru a găsi numărul total de minute
dintre două obiecte DateTime:

DateTime myDate1 = DateTime.Now; DateTime

myDate2 = DateTime.Now.AddHours(3000);

Diferența de timp; diferență =

myDate2.Scădere(myDate1);
număr dubluOfMinutes; numberOfMinutes =
diferență. MinuteTotale;

Clasele DateTime și TimeSpan acceptă, de asemenea, operatorii aritmetici + și -, care fac aceeași muncă
ca metodele încorporate. Asta înseamnă că puteți rescrie exemplul prezentat mai devreme astfel:

Adăugarea unui TimeSpan la un DateTime creează un nou

DateTime. DateTime myDate1 = DateTime.Now; Interval interval
interval de timp = TimeSpan.FromHours(3000); DateTime myDate2
= myDate1 + interval;
Scăderea unui obiect DateTime din altul produce un TimeSpan. Diferența de
timp; diferență = myDate2 - myDate1;

Aceste exemple vă oferă o idee despre flexibilitatea oferită de .NET pentru manipularea datelor de
dată și oră. Tabelele 2-4 și 2-5 listează unele dintre cele mai utile caracteristici încorporate ale
obiectelor DateTime și TimeSpan.

34

Tabelul 2-4. Membri utili DateTime
Membru
Acum
Azi
An, dată, lună, oră, minut,
secundă și milisecundă
ZiuaSăptămânii
Adunare() și Scădere()
AddYears(), AddMonths(),
AddDays(), AddHours(),
AddMinutes(),
AddSeconds(),
AddMilliseconds()
ZileInLună()
IsLeapYear()
ToString()
Tabelul 2-5. Membri TimeSpan utili
Membru
zile, ore, minute,
secunde, milisecunde
TotalDays, TotalHours,
TotalMinutes, TotalSeconds,
TotalMilliseconds
CAPITOLUL LIMBA C#
2
Descriere
Obține data și ora curente. De asemenea, puteți utiliza proprietatea UtcNow
pentru a lua în considerare fusul orar curent al computerului. UtcNow primește
timpul ca timp universal coordonat (UTC). Presupunând că computerul este
configurat corect, aceasta corespunde orei curente din fusul orar
vest-european (UTC+0).
Obține data curentă și lasă ora setată la 00:00:00.
Returnează o parte a obiectului DateTime ca întreg. De exemplu,
Month va returna 12 pentru orice zi din decembrie.
Returnează o valoare enumerată care indică ziua săptămânii pentru
această DatăOră, utilizând enumerarea DayOfWeek. De exemplu, dacă
data cade duminică, aceasta va returna DayOfWeek.Sunday.
Adaugă sau scade un TimeSpan din DateTime. Pentru comoditate, acestea
sunt operațiuni sunt mapate la operatorii + și -, astfel încât să le puteți utiliza
în schimb atunci când efectuați calcule cu date.
Adaugă un întreg care reprezintă un număr de ani, luni etc. și returnează o
nouă DatăOră. Puteți utiliza un număr întreg negativ pentru a efectua o
scădere a datei.
Returnează numărul de zile din luna specificată din anul specificat.
Returnează true sau false în funcție de faptul dacă anul specificat este un
an bisect.
Returnează o reprezentare șir a obiectului DateTime curent. De asemenea,
puteți utiliza o versiune supraîncărcată a acestei metode care vă permite să
specificați un parametru cu un șir de format.
Descriere
Returnează o componentă a TimeSpan-ului curent. De exemplu,
proprietatea Ore poate returna un număr întreg de la –23 la 23.
Returnează valoarea totală a Intervalului de timp curent ca număr de zile,
ore, minute etc. Valoarea este returnată ca dublă, care poate include o
valoare fracționată. De exemplu, proprietatea TotalDays poate returna un
număr precum 234.342.
35
 CAPITOLUL LIMBA C#
2

Membru Descriere

Adunare() și Scădere() Combină obiectele TimeSpan împreună. Pentru comoditate, acestea

sunt operațiuni care sunt mapate la operatorii + și -, astfel încât să le
puteți utiliza în schimb atunci când efectuați calcule cu timpi.
FromDays(), FromHours(), Vă permite să creați rapid un nou interval de timp. De exemplu, puteți
FromMinutes(), utiliza TimeSpan.FromHours(24) pentru a crea un obiect TimeSpan de
FromSeconds(), exact 24 de ore.
FromMilliseconds()
ToString() Returnează o reprezentare șir a obiectului TimeSpan curent. De
asemenea, puteți utiliza o versiune supraîncărcată a acestei metode care
vă permite să specificați un parametru cu un șir de format.

Tipul matricei
Matricele se comportă, de asemenea, ca obiecte din lumea .NET. (Din punct de vedere tehnic, fiecare
matrice este o instanță a tipului System.Array.) De exemplu, dacă doriți să aflați dimensiunea unei matrice
unidimensionale, puteți utiliza proprietatea Lungime sau metoda GetLength(), ambele returnând numărul
total de elemente dintr-o matrice:
int[] myArray = {1, 2, 3, 4, 5}; int
numberOfElements;

numberOfElements = myArray.Length; numberOfElements = 5

De asemenea, puteți utiliza metoda GetUpperBound() pentru a găsi cel mai mare număr de index dintr-o matrice. Când
apelați GetUpperBound(), furnizați un număr care indică dimensiunea pe care doriți să o verificați. În cazul unei matrice
unidimensionale, trebuie să specificați întotdeauna 0 pentru a obține numărul index din prima dimensiune. Într-o matrice
bidimensională, puteți utiliza și 1 pentru a doua legătură; într-o matrice tridimensională, puteți utiliza și 2 pentru a treia
limită; și așa mai departe.
Următorul fragment de cod arată GetUpperBound() în acțiune:

int[] myArray = {1, 2, 3, 4, 5}; int

legat;
Zero reprezintă prima dimensiune a unei matrice. legat =
myArray.GetUpperBound(0); legat = 4
Într-o matrice unidimensională, GetUpperBound() returnează întotdeauna un număr cu unu mai mic decât lungimea.
Acest lucru se datorează faptului că primul număr de index este 0, iar ultimul număr de index este întotdeauna cu unul
mai mic decât numărul total de articole. Cu toate acestea, într-o matrice bidimensională, puteți găsi cel mai mare număr
de index pentru o anumită dimensiune din matricea respectivă. De exemplu, următorul fragment de cod utilizează
GetUpperBound() pentru a găsi numărul total de rânduri și numărul total de coloane dintr-o matrice bidimensională:

Creați o matrice 4x2 (o grilă cu patru rânduri și două coloane). int[,]

intArray = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};

int rows = intArray.GetUpperBound(0) + 1; rânduri = 4 int coloane =

intArray.GetUpperBound(1) + 1; coloane = 2

36
 CAPITOLUL LIMBA C#
2

Deținerea acestor valori - lungimea matricei și indexurile - este utilă atunci când parcurgeți în buclă conținutul unei
matrice, după cum veți vedea mai târziu în acest capitol din secțiunea "Bucle".
Matricele oferă, de asemenea, alte câteva metode utile, care vă permit să le sortați, să le inversați și să le
căutați pentru un element specificat. Tabelul 2-6 listează câțiva membri utili ai clasei System.Array.

Tabelul 2-6. Membri utili ai matricei

Membru Descriere

Lungime Returnează un număr întreg care reprezintă numărul total de elemente din
toate dimensiunile unei matrice. De exemplu, o matrice 3×3 are o lungime
de 9.
GetLowerBound() și Stabilește dimensiunile unei matrice. Ca și în cazul oricărui lucru din .NET,
GetUpperBound() începeți să numărați la zero (care reprezintă prima dimensiune).

Clar() Golește parțial sau integral conținutul unei matrice, în funcție de valorile
indexului pe care le furnizați. Elementele revin la valorile lor inițiale goale (cum
ar fi 0 pentru numere).

IndexOf() și Caută într-o matrice unidimensională o valoare specificată și returnează

LastIndexOf() numărul indexului. Nu puteți folosi acest lucru cu matrice multidimensionale.

Sortare() Sortează o matrice unidimensională formată din date comparabile, cum ar fi

șiruri de caractere sau numere.

Invers() Inversează o matrice unidimensională, astfel încât elementele sale să fie

înapoi, de la ultimul la primul.

Logica condițională
În multe privințe, logica condiționată – a decide ce acțiune să întreprindă pe baza datelor introduse de
utilizator, a condițiilor externe sau a altor informații – este inima programării.
Orice logică condițională începe cu o condiție: o expresie simplă care poate fi evaluată ca adevărată sau
falsă. Codul dvs. poate lua apoi o decizie de a executa o logică diferită în funcție de rezultatul condiției.
Pentru a construi o condiție, puteți utiliza orice combinație de valori literale sau variabile împreună cu
operatori logici. Tabelul 2-7 enumeră operatorii logici de bază.
Tabelul 2-7. Operatori logici

Operator Descriere

== Egal cu.

!= Nu este egal cu.

< Mai puţin.

> Mai mare decât.

37
 CAPITOLUL LIMBA C#
2

Operator Descriere

<= Mai mic sau egal cu.

>= Mai mare sau egal cu.

&& Logic și (evaluează la adevărat numai dacă ambele expresii sunt adevărate). Dacă prima
expresie este falsă, a doua expresie nu este evaluată.

|| Logic sau (evaluează la adevărat dacă oricare dintre expresii este adevărată). Dacă prima
expresie este adevărată, a doua expresie nu este evaluată.

Puteți utiliza toți operatorii de comparație cu orice tip numeric. Cu tipurile de date șir, puteți utiliza numai
operatorii de egalitate (== și !=). C# nu acceptă alte tipuri de operatori de comparare a șirurilor - în schimb,
trebuie să utilizați metoda String.Compare(). Metoda String.Compare() consideră că un șir este "mai mic
decât" un alt șir dacă apare mai devreme într-o sortare alfabetică. Astfel, mărul este mai puțin decât atașat.
Valoarea returnată din String.Compare este 0 dacă șirurile se potrivesc, 1 dacă primul șir furnizat este mai
Descărcați de la Wow! eBook <www.wowebook.com>

mare decât al doilea și –1 dacă primul șir este mai mic decât al doilea. Iată un exemplu:
int rezultat; rezultat = String.Compare ("măr", "atașare"); rezultat = -1
rezultat = String.Compare ("măr", "toate"); rezultat = 1 rezultat =
String.Compare ("măr", "măr"); rezultat = 0

Un alt mod de a efectua comparații de șiruri. șir de cuvinte = "măr";

rezultat = cuvânt. CompareTo("atașați"); rezultat = -1

Declarația if
Declarația if este centrul de putere al logicii condiționale, capabil să evalueze orice combinație de condiții și
să se ocupe de mai multe și diferite bucăți de date. Iată un exemplu cu o afirmație if care conține două
condiții:
dacă (myNumber > 10) { // Fă
ceva. } altceva dacă (myString ==
"salut") { // Fă ceva. } altceva { //
Fă ceva. }

Un bloc if poate avea orice număr de condiții. Dacă testați o singură condiție, nu trebuie să includeți alte
blocuri.

38
 CAPITOLUL LIMBA C#
2

Notă Îna acest

• pentru exemplu,
scrie mai multe fiecare blocîntr-un
linii de cod este identificat clar cu caracterele
bloc condițional. Dacă blocul{ }. Aceasta este
condițional o cerință dacă doriți
necesită
doar o singură declarație, puteți omite bretelele ondulate. Cu toate acestea, nu este niciodată o
idee rea să le păstrați, deoarece vă face codul clar și lipsit de ambiguitate.

Rețineți că construcția if corespunde cel mult unei condiții. De exemplu, dacă myNumber este mai mare
decât 10, prima condiție va fi îndeplinită. Asta înseamnă că codul din primul bloc condițional va rula și nu vor
fi evaluate alte condiții. Dacă myString conține textul salut devine irelevant, deoarece această condiție nu va
fi evaluată. Dacă doriți să verificați ambele condiții, nu utilizați un alt bloc - în schimb, aveți nevoie de două
blocuri dacă unul după altul, așa cum se arată aici:
dacă (myNumber > 10) { //
Faceți ceva. } dacă
(myString == "salut") { //
Faceți ceva. }

Instrucțiunea comutatorului
C# oferă, de asemenea, o instrucțiune de comutare pe care o puteți utiliza pentru a evalua o singură variabilă sau
expresie pentru mai multe valori posibile. Singura limitare este că variabila pe care o evaluați trebuie să fie un tip de
date bazat pe numere întregi, un bool, un char, un șir sau o valoare dintr-o enumerare. Alte tipuri de date nu sunt
acceptate.
În codul următor, fiecare caz examinează variabila myNumber și testează dacă este egală cu un întreg
specific:

switch (myNumber) { cazul 1: // Fă ceva. pauză; cazul 2: // Fă ceva. sparge; implicit: // Fă ceva. sparge; }

Veți observa că sintaxa C# moștenește convenția programării C / C ++, care necesită ca fiecare ramură
dintr-o instrucțiune de comutare să fie încheiată de un cuvânt cheie special de pauză. Dacă omiteți acest
cuvânt cheie, compilatorul vă va avertiza și va refuza să vă construiască aplicația. Singura excepție este
dacă alegeți să stivuiți mai multe declarații de caz direct unul peste celălalt, fără niciun cod de intervenție.
Acest lucru vă permite să scrieți un segment de cod care gestionează mai multe cazuri. Iată un exemplu:

39
 CAPITOLUL LIMBA C#
2

switch (myNumber) { cazul 1: cazul 2: // Acest cod se execută dacă myNumber este 1 sau 2. pauză; implicit: // Fă ceva.

sparge; }

Spre deosebire de instrucțiunea if, instrucțiunea de comutare este limitată la evaluarea unei singure informații
la un moment dat. Cu toate acestea, oferă o sintaxă mai slabă și mai clară decât instrucțiunea if pentru
situațiile în care trebuie să testați o singură variabilă.

Bucle
Buclele vă permit să repetați un segment de cod de mai multe ori. C# are trei tipuri de bază de bucle. Alegeți
tipul de buclă în funcție de tipul de activitate pe care trebuie să o efectuați. Alegerile dvs. sunt următoarele:
• Puteți face buclă de un anumit număr de ori cu o buclă for.
• Puteți trece în buclă prin toate elementele dintr-o colecție de date utilizând o buclă foreach.
• Puteți bucla în timp ce o anumită condiție este valabilă cu un timp sau faceți ... în buclă.
Buclele pentru și pentru fiecare sunt ideale pentru mestecarea seturilor de date care au dimensiuni
cunoscute, fixe. Bucla while este o construcție mai flexibilă care vă permite să continuați procesarea până
când este îndeplinită o condiție complexă. Bucla while este adesea folosită cu sarcini repetitive sau calcule
care nu au un număr stabilit de iterații.

Pentru buclă
Bucla pentru este un ingredient de bază în multe programe. Vă permite să repetați un bloc de cod de un
anumit număr de ori, utilizând un contor încorporat. Pentru a crea o buclă for, trebuie să specificați o valoare
de pornire, o valoare finală și suma de incrementat cu fiecare trecere. Iată un exemplu:
pentru (int i = 0; i < 10; i++) { // Acest cod se
execută de zece ori.
System.Diagnostics.Debug.Write(i); }

Veți observa că bucla pentru începe cu paranteze care indică trei informații importante. Prima porțiune (int i
= 0) creează contravariabila (i) și stabilește valoarea inițială (0). A treia porțiune, (i++), incrementează
contravariabila. În acest exemplu, contorul este incrementat cu 1 după fiecare trecere. Asta înseamnă că i
va fi egal cu 0 pentru prima trecere, egal cu 1 pentru a doua trecere și așa mai departe. Cu toate acestea,
puteți ajusta această afirmație astfel încât să micșoreze contorul (sau să efectueze orice altă operație doriți).
Partea din mijloc, (i < 10), specifică condiția care trebuie îndeplinită pentru ca bucla să continue. Această
condiție este testată la începutul fiecărei treceri prin bloc. Dacă i este mai mare sau egal cu 10, condiția se
va evalua la fals și bucla se va termina.

40
 CAPITOLUL LIMBA C#
2

Dacă rulați acest cod utilizând un instrument, cum ar fi Visual Studio, acesta va scrie următoarele
numere în fereastra Debug:
0123456789
De multe ori este logic să setați contravariabila pe baza numărului de articole pe care le procesați. De
exemplu, puteți utiliza o buclă for pentru a parcurge elementele dintr-o matrice, verificând dimensiunea
matricei înainte de a începe. Iată codul pe care l-ați utiliza:
string[] stringArray = {"unu", "doi", "trei"};

pentru (int i = 0; i < stringArray.Length; i++) {

System.Diagnostics.Debug.Write(stringArray[i] + " "); }

Acest cod produce următoarea ieșire:

un doi trei

DOMENIUL DE APLICARE LA NIVEL DE BLOC

Dacă definiți o variabilă în interiorul unui fel de structură de blocuri (cum ar fi o buclă sau un bloc
condițional), variabila este lansată automat atunci când codul iese din bloc. Asta înseamnă că nu îl veți
mai putea accesa. Următorul cod demonstrează acest comportament:
int tempVariableA; pentru (int i = 0; i < 10; i++) { int
tempVariableB; tempVariableA = 1; tempVariableB =
1; } // Nu puteți accesa tempVariableB aici. Cu toate
acestea, puteți accesa în continuare tempVariableA.

Această modificare nu va afecta multe programe. Este într-adevăr conceput pentru a prinde
câteva erori accidentale. Dacă aveți nevoie să accesați o variabilă în interiorul și în afara
unui anumit tip de structură de blocuri, definiți variabila înainte de începerea blocării.

Bucla foreach
C# oferă, de asemenea, o buclă pentrufiecare care vă permite să faceți buclă prin elementele dintr-un set de date. Cu o
buclă foreach, nu este necesar să creați o contravariabilă explicită. În schimb, creați o variabilă care reprezintă tipul de
date pe care le căutați. Codul dvs. va fi apoi buclat până când veți avea șansa de a procesa fiecare bucată de date din
set.
Bucla foreach este deosebit de utilă pentru traversarea datelor din colecții și matrice. De exemplu, următorul
segment de cod trece prin elementele dintr-o matrice folosind foreach. Acest cod are exact același efect ca
exemplul anterior, dar este puțin mai simplu:

41
 CAPITOLUL LIMBA C#
2

string[] stringArray = {"unu", "doi", "trei"};

foreach (element șir în stringArray) { // Acest cod se buclează de trei ori, cu variabila elementului setată la // "unu", apoi "doi" și
apoi "trei".

System.Diagnostics.Debug.Write(element + " "); }

În acest caz, bucla foreach examinează fiecare element din matrice și încearcă să îl convertească într-un șir. Astfel,
bucla foreach definește o variabilă șir numită element. Dacă ați utilizat un alt tip de date, veți primi o eroare.

Bucla foreach are o limitare cheie: este doar în citire. De exemplu, dacă doriți să treceți în buclă printr-o
matrice și să modificați valorile din acea matrice în același timp, pentrufiecare cod nu ar funcționa. Iată un
exemplu de cod defect:
int[] intArray = {1,2,3}; foreach (int
num în intArray) { num += 1; }

În acest caz, ar trebui să reveniți la o buclă de bază cu un contor.

Bucla while
În cele din urmă, C# acceptă o buclă de timp care testează o anumită condiție înainte sau după fiecare trecere prin
buclă. Când această condiție este evaluată la false, bucla este ieșită.
Iată un exemplu care se repetă în buclă de zece ori. La începutul fiecărei treceri, codul evaluează
dacă contorul (i) este mai mic decât o limită superioară (în acest caz, 10). Dacă este, bucla
efectuează o altă iterație.
int i = 0; în timp
ce (i < 10) {

i + = 1; Acest cod se execută de zece

ori. }

De asemenea, puteți plasa condiția la sfârșitul buclei folosind do... în timp ce sintaxa. În acest caz, condiția
este testată la sfârșitul fiecărei treceri prin buclă:
int i = 0;
face {
i + = 1; Acest cod se execută de zece
ori. } în timp ce (I < 10);

Ambele exemple sunt echivalente, cu excepția cazului în care condiția pe care o testați este falsă pentru a
începe. În acest caz, bucla while va omite codul în întregime. Proiectul... În timp ce Loop, pe de altă parte,
va executa întotdeauna codul cel puțin o dată, deoarece nu testează starea până la sfârșit.

42
 CAPITOLUL LIMBA C#
2

• Sfat: Uneori trebuie să ieșiți în grabă dintr-o buclă. În C#, puteți utiliza instrucțiunea de pauză
pentru a ieși din orice tip de buclă. De asemenea, puteți utiliza instrucțiunea continuare pentru a
omite restul tichetului curent, pentru a evalua starea și (dacă este adevărat) pentru a începe
următoarea trecere.

Metode
Metodele sunt cel mai de bază bloc de construcție pe care îl puteți utiliza pentru a vă organiza codul. În
esență, o metodă este o grupare numită a uneia sau mai multor linii de cod. În mod ideal, fiecare metodă va
îndeplini o sarcină distinctă, logică. Prin descompunerea codului în metode, nu numai că vă simplificați viața,
dar vă ușurați și organizarea codului în clase și intrarea în lumea programării orientate pe obiecte. Prima
decizie pe care trebuie să o luați atunci când declarați o metodă este dacă doriți să returnați informații. De
exemplu, o metodă numită GetStartTime() poate returna un obiect DateTime care reprezintă ora la care a
fost pornită pentru prima dată o aplicație. O metodă poate returna, cel mult, o bucată de date. Când declarați
o metodă în C#, prima parte a declarației specifică tipul de date al valorii returnate, iar a doua parte indică
numele metodei. Dacă metoda nu returnează nicio informație, trebuie să utilizați cuvântul cheie nul în locul
unui tip de date de la începutul declarației.
Iată două exemple - o metodă care nu returnează nimic și una care o face:

Această metodă nu returnează nicio informație. void

MyMethodNoReturnedData() { // Codul merge aici.

Această metodă returnează un întreg. int

MyMethodReturnsData() { // De exemplu,
returnați numărul 10. returnarea 10; }

Observați că numele metodei este întotdeauna urmat de paranteze. Acest lucru permite compilatorului să
recunoască faptul că este o metodă.
În acest exemplu, metodele nu specifică accesibilitatea acestora. Aceasta este doar o convenție comună C#. Aveți
libertatea de a adăuga un cuvânt cheie de accesibilitate (cum ar fi public sau privat), după cum se arată aici:

void MyMethodNoReturnedData()
privat { // Codul merge
aici.
}

Accesibilitatea determină modul în care pot interacționa diferite clase din codul dvs. Metodele private sunt
ascunse vederii și sunt disponibile numai local, în timp ce metodele publice pot fi apelate de toate celelalte
clase din aplicația dvs. Pentru a înțelege cu adevărat ce înseamnă acest lucru, va trebui să citiți capitolul
următor, care discută mai detaliat accesibilitatea.

43
 CAPITOLUL LIMBA C#
2

Sfat: Dacă nu specificați accesibilitatea, metoda este întotdeauna privată. Exemplele din această carte includ întotdeauna
•
cuvinte cheie de accesibilitate, deoarece îmbunătățesc claritatea. Majoritatea
programatorilor sunt de acord că este o abordare bună pentru a preciza în mod explicit
accesibilitatea codului dvs.

Invocarea metodelor este simplă - pur și simplu tastați numele metodei, urmat de paranteze. Dacă metoda
returnează date, aveți opțiunea de a utiliza datele pe care le returnează sau pur și simplu de a le ignora:

Acest apel este permis.

MyMethodNoReturnedData();

Acest apel este permis.

MyMethodReturnsData();

Acest apel este permis. int

myNumber; myNumber =
MyMethodReturnsData();
Acest apel nu este permis.
MyMethodNoReturnedData() nu returnează nicio informație.
myNumber = MyMethodNoReturnedData();

Parametrii
Metodele pot accepta, de asemenea, informații prin parametri. Parametrii sunt declarați în mod similar cu
variabilele. Prin convenție, numele parametrilor încep întotdeauna cu o literă mică în orice limbă. Iată cum
puteți crea o funcție care acceptă doi parametri și returnează suma acestora:
privat int AddNumbers(int number1, int number2) {
return number1 + number2; }

Când apelați o metodă, specificați parametrii necesari între paranteze sau utilizați un set gol de paranteze
dacă nu sunt necesari parametri:

Apelați o metodă fără parametri.

MyMethodNoReturnedData();

Apelați o metodă care necesită doi parametri întregi.

MyMethodNoReturnedData2(10, 20);

Apelați o metodă cu doi parametri întregi și o valoare returnată de numere întregi. int
returnValue = AddNumbers(10, 10);

44
 CAPITOLUL LIMBA C#
2

Metoda de supraîncărcare
C# acceptă supraîncărcarea metodei, care vă permite să creați mai multe metode cu același nume, dar cu un set diferit
de parametri. Când apelați metoda, CLR alege automat versiunea corectă examinând parametrii pe care îi furnizați.

Această tehnică vă permite să colectați împreună diferite versiuni ale mai multor metode. De exemplu, puteți
permite o căutare în baza de date care returnează o matrice de obiecte Produs reprezentând înregistrări din
baza de date. În loc să creați trei metode cu nume diferite în funcție de criterii, cum ar fi GetAllProducts(),
GetProductsInCategory() și GetActiveProducts(), puteți crea trei versiuni ale metodei GetProducts(). Fiecare
metodă ar avea același nume, dar o semnătură diferită, ceea ce înseamnă că ar necesita parametri diferiți.
Acest exemplu oferă două versiuni supraîncărcate pentru metoda GetProductPrice():

zecimal privat GetProductPrice (int ID) { //

Cod aici.

zecimal privat GetProductPrice (nume șir) { // Cod

aici.

Și așa mai departe...

Acum puteți căuta prețurile produselor pe baza ID-ului unic al produsului sau a numelui complet al
produsului, în funcție de faptul dacă furnizați un argument întreg sau șir:

preț zecimal;

Obțineți prețul după ID-ul produsului (prima versiune).

preț = GetProductPrice (1001);
Obțineți prețul după numele produsului (a doua versiune).
preț = GetProductPrice ("DVD Player");

Nu puteți supraîncărca o metodă cu versiuni care au aceeași semnătură - adică același număr de parametri
și tipuri de date de parametri - deoarece CLR nu le va putea distinge între ele. Când apelați o metodă
supraîncărcată, se utilizează versiunea care se potrivește cu lista de parametri pe care o furnizați. Dacă nu
se potrivește nicio versiune, apare o eroare.

• Notă . NET utilizează metode supraîncărcate în majoritatea claselor sale. Această abordare
vă permite să utilizați o gamă flexibilă de parametri în timp ce centralizați funcționalitatea sub
nume comune. Chiar și metodele pe care le-ați văzut până acum (cum ar fi metodele String
pentru umplerea sau înlocuirea textului) au mai multe versiuni care oferă caracteristici similare cu
diverse opțiuni.

45
 CAPITOLUL LIMBA C#
2

Parametri opționali și denumiți

Metoda de supraîncărcare este o tehnică onorată în timp pentru a face metodele mai flexibile, astfel încât să le
puteți apela într-o varietate de moduri diferite. C# 4 adaugă o altă caracteristică care acceptă același obiectiv:
parametri opționali.
Un parametru opțional este orice parametru care are o valoare implicită. Dacă metoda dvs. are
parametri normali și parametri opționali, parametrii opționali trebuie plasați la sfârșitul listei de
parametri. Iată un exemplu de metodă care are un singur parametru opțional:
șir privat GetUserName(int ID, )
bool useShortForm = false { // Cod aici.

Aici, parametrul useShortForm este opțional, ceea ce vă oferă două modalități de a apela metoda
GetUserName ():

Setați explicit parametrul useShortForm. name =

GetUserName(401, adevărat);

Nu setați parametrul useShortForm și utilizați valoarea implicită (false). nume = GetUserName(401);

Uneori, veți avea o metodă cu mai mulți parametri opționali, cum ar fi aceasta:

zecimal privat GetSalesTotalForRegion(int regionID, zecimal minSale = 0, zecimal

maxSale = Decimal.MaxValue, bool includeTax = false) { // Cod aici.

În această situație, cea mai ușoară opțiune este să alegeți parametrii pe care doriți să îi setați după
nume. Această caracteristică se numește parametri numiți și, pentru a o utiliza, pur și simplu adăugați
numele parametrului urmat de două puncte (:), urmat de valoare, așa cum se arată aici:
total = GetSalesTotalForRegion(523, );
maxVânzare: 5000
Deși puteți realiza multe dintre aceleași lucruri cu parametrii opționali și supraîncărcarea metodei, clasele sunt mai
susceptibile de a utiliza supraîncărcarea metodei din două motive. În primul rând, majoritatea claselor din .NET au fost
create în versiunile anterioare, când C# nu suporta parametri opționali. În al doilea rând, nu toate limbile .NET acceptă
parametri opționali (deși C# și VB o fac).
De asemenea, este demn de remarcat faptul că supraîncărcarea metodei vă permite să vă ocupați de
oricare / sau situații, în timp ce parametrii opționali nu. De exemplu, metoda GetProductPrice() prezentată în
secțiunea anterioară a necesitat un șir sau un număr întreg. Nu este acceptabil să le transformăm pe
amândouă în parametri opționali, deoarece este necesar cel puțin unul, iar furnizarea celor doi simultan nu
are sens. Astfel, aceasta este o situație în care supraîncărcarea metodei se potrivește mai natural.

46
 CAPITOLUL LIMBA C#
2

Delegaţi
Delegații vă permit să creați o variabilă care "indică" o metodă. Puteți utiliza această variabilă în orice moment
pentru a invoca metoda. Delegații vă ajută să scrieți cod flexibil care poate fi reutilizat în multe situații. Ele sunt, de
asemenea, baza evenimentelor, un concept important .NET pe care îl veți lua în considerare în capitolul următor.

Primul pas atunci când utilizați un delegat este definirea semnăturii acestuia. Semnătura este o combinație de
mai multe informații despre o metodă: tipul său de returnare, numărul de parametri pe care îi are și tipul de date
al fiecărui parametru.
O variabilă delegată poate indica numai o metodă care se potrivește cu semnătura sa specifică. Cu alte cuvinte,
metoda trebuie să aibă același tip de returnare, același număr de parametri și același tip de date pentru fiecare
parametru ca delegatul. De exemplu, dacă aveți o metodă care acceptă un singur parametru șir și o altă metodă
care acceptă doi parametri șir, va trebui să utilizați un tip de delegat separat pentru fiecare metodă.

Pentru a lua în considerare modul în care funcționează acest lucru în practică, presupuneți că programul dvs. are următoarea metodă:

șir privat TranslateEnglishToFrench(șir engleză) { // Codul

merge aici.

Această metodă acceptă un argument cu un singur șir și returnează un șir. Având în vedere aceste două
detalii, puteți defini un delegat care se potrivește cu această semnătură. Iată cum ați face-o:
șir delegat privat StringFunction(string inputString);
Observați că numele pe care îl alegeți pentru parametri și numele delegatului nu contează. Singura cerință
este ca tipurile de date pentru valoarea și parametrii returnați să se potrivească exact. După ce ați definit un
tip de delegat, puteți crea și atribui oricând o variabilă delegată. Folosind tipul de delegat StringFunction,
puteți crea o variabilă delegată ca aceasta:
StringFunction functionReference;
Odată ce aveți o variabilă delegată, începe distracția. Folosind variabila delegat, puteți indica orice metodă
care are semnătura corespunzătoare. În acest exemplu, tipul delegat StringFunction necesită un parametru
șir și returnează un șir. Astfel, puteți utiliza variabila functionReference pentru a stoca o referință la metoda
TranslateEnglishToFrench() pe care ați văzut-o mai devreme. Iată cum se face:
functionReference = Traducere englezăîn franceză;

Notă atribuiți o metodă unei variabile delegate în C#, nu utilizați paranteze după numele
• Când
metodei. Acest lucru indică faptul că vă referiți la metodă, nu încercați să o executați. Dacă ați
adăugat parantezele, CLR ar încerca să ruleze metoda și să convertească valoarea returnată la
tipul delegat, ceea ce nu ar funcționa (și, prin urmare, ar genera o eroare de compilare).

Acum că aveți o variabilă delegată care face referire la o metodă, puteți invoca metoda prin intermediul
delegatului. Pentru a face acest lucru, utilizați doar numele delegatului ca și cum ar fi numele metodei:

47
 CAPITOLUL LIMBA C#
2

coardă francezăString; frenchString =

functionReference("Salut");

În exemplul de cod anterior, metoda la care indică delegatul funcțieReference va fi invocată cu

valoarea parametrului "Hello", iar valoarea returnată va fi stocată în variabila frenchString.

Următorul cod afișează toți acești pași - crearea unei variabile delegate, atribuirea unei metode și
apelarea metodei - de la început până la sfârșit:

Creați o variabilă delegată.

StringFunction functionReference;

Stocați o referință la o metodă de potrivire în delegat.

functionReference = Traducere englezăîn franceză;

Executați metoda la care funcționeazăPuncte de referință. În

acest caz, va fi TranslateEnglishToFrench(). string frenchString
= functionReference("Hello");

Valoarea delegaților constă în stratul suplimentar de flexibilitate pe care îl adaugă. Nu este evident în acest
Descărcați de la Wow! eBook <www.wowebook.com>

exemplu, deoarece aceeași bucată de cod creează variabila delegată și o utilizează. Cu toate acestea,
într-o aplicație mai complexă, o metodă ar crea variabila delegată, iar o altă metodă ar folosi-o. Beneficiul
în acest scenariu este că a doua metodă nu trebuie să știe unde indică delegatul. În schimb, este suficient
de flexibil pentru a utiliza orice metodă care are semnătura potrivită. În exemplul actual, imaginați-vă o
bibliotecă de traduceri care ar putea traduce între engleză și o varietate de limbi diferite, în funcție de faptul
dacă delegatul pe care îl folosește indică TranslateEnglishToFrench(), TranslateEnglishToSpanish(),
TranslateEnglishToGerman() și așa mai departe.

DELEGAȚII SUNT BAZA EVENIMENTELOR

Nu ar fi frumos să avem un delegat care să se refere la mai multe funcții simultan și să le invoce simultan?
Acest lucru ar permite aplicației client să aibă mai mulți "ascultători" și să notifice ascultătorii simultan
atunci când se întâmplă ceva.
De fapt, delegații au această funcționalitate, dar este mai probabil să o vedeți utilizată cu
evenimente .NET. Evenimentele, care sunt descrise în capitolul următor, se bazează pe
delegați, dar lucrează la un nivel ușor mai înalt. Într-un program tipic de ASP.NET, veți
utiliza evenimente pe scară largă, dar probabil că nu veți lucra niciodată direct cu
delegații.

Ultimul cuvânt
Este imposibil să faci dreptate unei întregi limbi într-un singur capitol. Cu toate acestea, dacă ați programat înainte, veți
descoperi că acest capitol oferă toate informațiile de care aveți nevoie pentru a începe cu limbajul C #. Pe măsură ce
parcurgeți exemplele complete de ASP.NET din capitolele următoare, puteți consulta acest capitol pentru a clarifica orice
probleme lingvistice.
În capitolul următor, veți afla despre concepte lingvistice mai importante și despre natura orientată pe
obiecte a .NET.

48
CAPITOLUL3

•■■

Tipuri, obiecte și spații de nume

.NET este complet orientat pe obiecte. Nu numai că .NET vă permite să utilizați obiecte, dar o cere. Aproape
fiecare ingredient pe care va trebui să-l utilizați pentru a crea o aplicație web este, la un anumit nivel, într-adevăr
un fel de obiect.
Deci, cât de mult trebuie să știți despre programarea orientată pe obiecte pentru a scrie pagini .NET? Depinde dacă doriți să
urmați exemplele existente și să tăiați și să lipiți mostre de cod sau să aveți o înțelegere mai profundă a modului în care
funcționează .NET și să obțineți mai mult control. Această carte presupune că, dacă ești dispus să iei o carte de o mie de
pagini, atunci ești tipul de programator care excelează înțelegând cum și de ce lucrurile funcționează așa cum o fac. De
asemenea, presupune că sunteți interesat de unele dintre sarcinile avansate de programare ASP.NET care vor necesita
proiectare bazată pe clasă, cum ar fi crearea propriei componente a bazei de date (a se vedea capitolul 22).

Acest capitol explică obiectele din punctul de vedere al .NET Framework. Nu reia teoria tipică orientată pe obiecte,
deoarece nenumărate cărți excelente de programare acoperă subiectul. În schimb, veți vedea tipurile de obiecte
permise de .NET, modul în care sunt construite și modul în care se încadrează în cadrul mai larg al spațiilor de nume
și al ansamblurilor.

Noțiuni de bază despre cursuri

Ca dezvoltator, probabil că ați creat deja cursuri sau cel puțin ați auzit despre ele. Clasele sunt definițiile de cod pentru
obiecte. Lucrul frumos despre o clasă este că o puteți folosi pentru a crea cât mai multe obiecte de care aveți nevoie. De
exemplu, este posibil să aveți o clasă care reprezintă un fișier XML, care poate fi utilizat pentru a citi unele date. Dacă
doriți să accesați mai multe fișiere XML simultan, puteți crea mai multe instanțe ale clasei dvs., așa cum se arată în
Figura 3-1. Aceste instanțe se numesc obiecte.

49
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Figura 3-1. Clasele sunt folosite pentru a crea obiecte.

Clasele interacționează între ele cu ajutorul a trei ingrediente cheie:

• Proprietăți: Proprietățile vă permit să accesați datele unui obiect. Unele proprietăți
pot fi doar în citire, deci nu pot fi modificate, în timp ce altele pot fi modificate. De
exemplu, capitolul anterior a demonstrat cum puteți utiliza proprietatea Lungime
doar în citire a unui obiect Șir pentru a afla câte litere sunt într-un șir.
• Metode: Metodele vă permit să efectuați o acțiune asupra unui obiect. Spre deosebire de
proprietăți, metodele sunt utilizate pentru acțiuni care efectuează o sarcină distinctă sau
pot schimba semnificativ starea obiectului. De exemplu, pentru a deschide o conexiune la
o bază de date, puteți apela o metodă Open() într-un obiect Conexiune.
• Evenimente: Evenimentele anunță că s-a întâmplat ceva. Dacă ați programat
vreodată o aplicație Windows modernă, știți cum controalele pot declanșa
evenimente pentru a declanșa codul. De exemplu, dacă un utilizator face clic pe un
buton, obiectul Buton declanșează un eveniment Clic, la care codul poate
reacționa. Controalele ASP.NET oferă, de asemenea, evenimente.
În plus, clasele conțin propriul cod și setul intern de date private. Clasele se comportă ca niște cutii negre, ceea ce
înseamnă că atunci când utilizați un obiect, nu ar trebui să pierdeți timpul întrebându-vă cum funcționează sau ce
informații de nivel scăzut folosește. În schimb, trebuie să vă faceți griji doar cu privire la interfața publică a unei clase,
care este setul de proprietăți, metode și evenimente disponibile pentru utilizare. Împreună, aceste elemente sunt numite
membri ai clasei.
În ASP.NET, veți crea propriile clase personalizate pentru a reprezenta pagini web individuale. În plus, veți crea
clase particularizate dacă proiectați componente separate. Cu toate acestea, în cea mai mare parte, veți utiliza
clase predefinite din biblioteca de clase .NET, mai degrabă decât să vă programați propriile clase.

Membri statici
Unul dintre trucurile despre clasele .NET este că le folosiți cu adevărat în două moduri. Puteți folosi unii
membri ai clasei fără a crea mai întâi un obiect. Acestea se numesc membri statici și sunt accesate după
numele clasei. De exemplu, puteți utiliza proprietatea statică DateTime. Acum pentru a regăsi un obiect
DateTime care reprezintă data și ora curente. Nu este necesar să creați mai întâi un obiect DateTime.

50
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Pe de altă parte, majoritatea membrilor DateTime necesită o instanță validă. De exemplu, nu puteți utiliza
metoda AddDays() sau proprietatea Hour fără un obiect valid. Acești membri ai instanței nu au niciun sens
fără un obiect viu și câteva date valide pe care să se bazeze. Următorul fragment de cod utilizează
membri statici și instanțe:
Obțineți data curentă utilizând o proprietate statică. Rețineți
că trebuie să utilizați numele clasei DateTime. DateTime
myDate = DateTime.Now;
Utilizați o metodă de instanță pentru a adăuga o zi.
Rețineți că trebuie să utilizați numele obiectului myDate.
myDate = myDate.AddDays(1);

Următorul cod nu are sens.

Încearcă să utilizeze metoda de instanță AddDays() cu numele clasei DateTime! myDate =
DateTime.AddDays(1);
Atât proprietățile, cât și metodele pot fi desemnate ca statice. Proprietățile și metodele statice sunt o parte importantă a
.NET Framework și le veți folosi frecvent în această carte. Unele clase pot consta în întregime din membri statici (cum ar
fi clasa de matematică prezentată în capitolul anterior), iar unele pot folosi numai membri ai instanței. Alte clase, cum ar fi
DateTime, oferă o combinație a celor două.
Următorul exemplu, care introduce o clasă de bază, va folosi doar membrii instanței. Acesta este cel mai
comun design și un bun punct de plecare.

O clasă simplă
Pentru a crea o clasă, trebuie să o definiți folosind o structură specială de blocuri:

clasa publică MyClass { // Codul

clasei merge aici. }

Puteți defini oricâte clase aveți nevoie în același fișier. Cu toate acestea, bunele practici de codificare
sugerează că, în majoritatea cazurilor, utilizați un singur fișier pentru fiecare clasă.
Clasele există în multe forme. Ele pot reprezenta un lucru real în lumea reală (așa cum se întâmplă în
majoritatea manualelor de programare), pot reprezenta o abstracție de programare (cum ar fi un dreptunghi
sau o structură de culoare) sau pot fi doar o modalitate convenabilă de a grupa funcționalitățile conexe (cum
ar fi ora de matematică). A decide ce ar trebui să reprezinte o clasă și a vă descompune codul într-un grup de
clase interdependente fac parte din arta programării.

Construirea unei clase de bază

În exemplul următor, veți vedea cum să construiți o clasă .NET bucată cu bucată. Această clasă va reprezenta
un produs din catalogul unei companii de comerț electronic. Clasa Product va stoca datele despre produse și va
include funcționalitatea încorporată necesară pentru a genera un bloc HTML care afișează produsul pe
o pagină web. Când această clasă este completă, veți putea să o puneți la lucru cu un exemplu
ASP.NET pagină de test.

51
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

După ce ați definit o clasă, primul pas este să adăugați câteva date de bază. Următorul exemplu definește
trei variabile membre care stochează informații despre produs, și anume, numele acestuia, prețul său și o
adresă URL care indică un fișier imagine:
clasa publică Produs {nume șir privat; preț zecimal privat; șir privat imageUrl; }

O variabilă locală există numai până la terminarea metodei curente. Pe de altă parte, o variabilă (sau un câmp) membru
este declarată ca parte a unei clase. Este disponibil pentru toate metodele din clasă și trăiește atâta timp cât trăiește
obiectul care conține.
Când creați o variabilă membru, îi setați accesibilitatea. Accesibilitatea determină dacă alte părți ale codului vor
putea citi și modifica această variabilă. De exemplu, dacă Clasa A conține o variabilă privată, codul din Clasa B nu
o va putea citi sau modifica. Numai codul din clasa A va avea această capacitate. Pe de altă parte, dacă ObjectA
are o variabilă publică, orice alt obiect din aplicația dvs. este liber să citească și să modifice informațiile pe care le
conține. Variabilele locale nu acceptă cuvinte cheie de accesibilitate, deoarece nu pot fi niciodată puse la dispoziția
niciunui cod dincolo de procedura curentă. În general, într-o aplicație simplă de ASP.NET, majoritatea variabilelor
dvs. vor fi private, deoarece majoritatea codului dvs. va fi autonom într-o singură clasă de pagini web. Cu toate
acestea, pe măsură ce începeți să creați componente separate pentru a reutiliza funcționalitatea, accesibilitatea
devine mult mai importantă. Tabelul 3-1 explică nivelurile de acces pe care le puteți utiliza.

Tabelul 3-1. Cuvinte cheie de accesibilitate

Cuvânt cheie Accesibilitate

public Poate fi accesat de orice clasă

privat Poate fi accesat doar de membrii clasei curente

intern Poate fi accesat de membrii din oricare dintre clasele din ansamblul curent
(fișierul cu codul compilat)

protejat Poate fi accesat de membrii clasei curente sau din orice clasă care moștenește
de la această clasă

Protecție internă Poate fi accesat de membri în aplicația curentă (ca și în cazul intern) și de
membrii din orice clasă care moștenește de la această clasă

Cuvintele cheie de accesibilitate nu se aplică doar variabilelor. Ele se aplică, de asemenea, metodelor,
proprietăților și evenimentelor, toate acestea urmând să fie explorate în acest capitol.

• Sfat Prin convenție, toate piesele publice ale clasei dvs. (numele clasei, evenimentele publice, proprietățile și
procedurile etc.) ar trebui să utilizeze cazul Pascal. Aceasta înseamnă că numele începe cu o majusculă inițială.

52
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

(Numele funcției DoSomething() este un exemplu de caz Pascal.) Pe de altă parte, membrii privați pot folosi orice caz
doriți. De obicei, membrii privați vor adopta cazul cămilei. Aceasta înseamnă că numele începe cu o literă mică
inițială. (Numele variabilei myInformation este un exemplu de caz de cămilă.) Unii dezvoltatori încep toate numele
membrilor privați cu _ sau m_ (pentru membru), deși aceasta este pur și simplu o chestiune de convenție.

Crearea unui obiect

Când creați un obiect, trebuie să specificați noul cuvânt cheie. Noul cuvânt cheie instanțiază obiectul, ceea ce înseamnă
că se prinde de o bucată de memorie și creează obiectul acolo. Dacă declarați o variabilă pentru obiectul dvs., dar nu
utilizați noul cuvânt cheie pentru a-l instanția, veți primi infama eroare "referință nulă" atunci când încercați să utilizați
obiectul. Acest lucru se datorează faptului că obiectul pe care încercați să îl utilizați nu există de fapt, iar variabila dvs. nu
indică nimic.
Următorul fragment de cod creează un obiect bazat pe clasa de produse și apoi îl lansează:

Vânzarea produsuluiProdus = Produs nou();

Opțional, puteți face acest lucru în doi pași: //

Vânzare produsProdus; saleProduct = Produs
nou();
Acum eliberați obiectul din memorie. saleProduct = nul;

În .NET, aproape niciodată nu trebuie să utilizați ultima linie, care eliberează obiectul. Acest lucru se
datorează faptului că obiectele sunt eliberate automat atunci când variabila corespunzătoare iese din
domeniul de aplicare. Obiectele sunt, de asemenea, eliberate atunci când aplicația se termină. Într-o pagină
web ASP.NET, aplicația dvs. are doar câteva secunde de trăit. Odată ce pagina web este redată în HTML,
aplicația se termină și toate obiectele sunt lansate automat.

Sfat pentru că un obiect este eliberat nu înseamnă că memoria pe care o utilizează este
• Doar
recuperată imediat. CRJ utilizează un serviciu de lungă durată (numit colectarea gunoiului) care
scanează periodic obiectele eliberate și recuperează memoria pe care o dețin.

În unele cazuri, veți dori să declarați o variabilă obiect fără a utiliza noul cuvânt cheie pentru a o crea. De
exemplu, poate doriți să atribuiți variabilei obiect o instanță care există deja. Sau este posibil să primiți un
obiect viu ca valoare returnată de la o funcție. Următorul cod prezintă un astfel de exemplu:

53
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Declarați, dar nu creați produsul. Vânzarea

produsuluiProdus;
Apelați o funcție care acceptă un parametru numeric ID produs, // și
returnează un obiect produs.
saleProduct = FetchProduct(23);

Odată ce înțelegeți conceptul, puteți comprima acest cod într-o singură afirmație:

Vânzarea produsuluiProdus = FetchProduct(23);

În aceste cazuri, atunci când nu creați efectiv un obiect, nu ar trebui să utilizați noul cuvânt cheie.

Adăugarea proprietăților
Clasa simplă de produse este în esență inutilă, deoarece codul dvs. nu o poate manipula. Toate informațiile sale sunt
private și inaccesibile. Alte clase nu vor putea seta sau citi aceste informații. Pentru a depăși această limitare, puteți
face publice variabilele membrilor. Din păcate, această abordare ar putea duce la probleme, deoarece ar oferi altor
obiecte acces liber pentru a schimba totul, permițându-le chiar să aplice date nevalide sau inconsecvente. În schimb,
trebuie să adăugați un "panou de control" prin care codul dvs. poate manipula obiectele produsului într-un mod sigur.
Faceți acest lucru adăugând
accesorii imobiliare.
Accesoriile au de obicei două părți. Accesorul de obținere permite codului să preia date din obiect. Accesorul setat
permite codului să seteze datele obiectului. În unele cazuri, este posibil să omiteți una dintre aceste părți, cum ar fi
atunci când doriți să creați o proprietate care poate fi examinată, dar nu modificată. Accesoriile sunt similare cu
orice alt tip de metodă prin faptul că puteți scrie cât de mult cod aveți nevoie. De exemplu, accesatorul setului de
proprietăți ar putea genera o eroare pentru a alerta codul clientului cu privire la datele nevalide și pentru a împiedica
aplicarea modificării. Sau, accesorul setului de proprietăți ar putea modifica mai multe variabile private simultan,
asigurându-se astfel că starea internă a obiectului rămâne consecventă. În exemplul cu clasa de produse, această
sofisticare nu este necesară. În schimb, accesoriile imobiliare oferă doar acces direct la variabilele private. De
exemplu, proprietatea Name pur și simplu obține sau setează valoarea variabilei name private member.
Accesoriile imobiliare, ca orice altă piesă publică dintr-o clasă, ar trebui să înceapă cu un capital inițial.
Acest lucru vă permite să dați același nume accesorului proprietății și variabilei private subiacente, deoarece
acestea vor avea majuscule diferite, iar C# este un limbaj sensibil la litere mari și mici. (Acesta este unul
dintre rarele cazuri în care este acceptabil să se facă diferența între două elemente bazate pe majuscule.) O
altă opțiune ar fi să precedați numele variabilei private cu un caracter de subliniere sau caracterele m_
(pentru variabila membru).
clasa publică Produs {nume șir privat; preț zecimal privat; șir privat imageUrl;

șir public Nume { get {

return name; } set } } {
name = value;

54
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII
3 DE NUME

preț zecimal public { get { preț dus; } set { preț = valoare; } }

șir public ImageUrl { get { return imageUrl; } set { imageUrl = value; } } }

Notă În instrumentul de setare a proprietății, accesați valoarea aplicată utilizând cuvântul cheie valoare. În esență,
•
Valoarea este un parametru care este transmis automat codului de setare a proprietății.

Clientul poate crea și configura acum obiectul utilizând proprietățile sale și sintaxa familiară a punctelor. De
exemplu, dacă variabila obiect se numește saleProduct, puteți seta numele produsului utilizând proprietatea
saleProduct.Name. Iată un exemplu:

Vânzarea produsuluiProdus = Produs nou();

saleProduct.Name = "gunoi de bucătărie";
saleProduct.Price = 49.99M; saleProduct.ImageUrl =
"http://mysite/garbage.png";
Veți observa că acest exemplu folosește un M pentru a indica faptul că numărul literal 49,99 trebuie
interpretat ca o valoare zecimală, nu ca o dublă.
De obicei, accesoriile imobiliare vin în perechi - adică fiecare proprietate are atât un accesor de obținere,
cât și un accesoriu setat. Dar acest lucru nu este întotdeauna cazul. Puteți crea proprietăți care pot fi citite,
dar nu setate (numite proprietăți doar în citire) și puteți crea proprietăți care pot fi setate, dar nu regăsite
(numite proprietăți doar pentru scriere ). Tot ce trebuie să faceți este să lăsați accesorul de care nu aveți
nevoie. Iată un exemplu de proprietate doar în citire:
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

preț zecimal public { get { preț dus-întors; } }

Această tehnică este deosebit de utilă dacă doriți să creați proprietăți care nu corespund direct unei
variabile private de membru. De exemplu, poate doriți să utilizați proprietăți care reprezintă valori calculate
sau să utilizați proprietăți bazate pe alte proprietăți.

Proprietăți automate
Dacă aveți proprietăți foarte simple - proprietăți care nu fac altceva decât să seteze sau să obțină valoarea unei
variabile private - puteți simplifica codul folosind o caracteristică de limbaj C# numită proprietăți automate. Proprietățile
automate sunt proprietăți fără niciun cod. Când utilizați o proprietate automată, o declarați, dar nu furnizați codul pentru
accesorii get and set și nu declarați variabila privată corespunzătoare. În schimb, compilatorul C# adaugă aceste detalii
pentru dvs.
Deoarece proprietățile din clasa Product obțin și setează pur și simplu variabilele membrilor, puteți înlocui
oricare dintre ele (sau pe toate) cu proprietăți automate. Iată un exemplu:

preț zecimal public {

obține; apus; }

Nu știți de fapt ce nume va alege compilatorul C# atunci când creează variabila corespunzătoare membrului privat. Cu
toate acestea, nu contează, deoarece nu va trebui niciodată să accesați direct variabila de membru privat. În schimb,
veți folosi întotdeauna proprietatea publică Preț.
Pentru și mai multe economii de spațiu, puteți comprima declarația unei proprietăți automate la o singură
linie. Iată o clasă completă de produse condensate care utilizează această tehnică:

clasa publică Produs { șir public Nume { get; set; } zecimal public Preț { get; set; } șir public ImageUrl { get; set; } }

Singurul dezavantaj al proprietăților automate este că va trebui să le comutați înapoi la proprietățile normale
dacă doriți să adăugați un cod mai specializat după fapt. De exemplu, poate doriți să adăugați cod care
efectuează validarea sau ridică un eveniment atunci când este setată o proprietate.

Adăugarea unei metode

Clasa actuală de produse constă în întregime din date, care sunt expuse de un set mic de proprietăți. Acest
tip de clasă este adesea util într-o aplicație. De exemplu, îl puteți utiliza pentru a trimite informații despre un
produs de la o funcție la alta. Cu toate acestea, este mai frecvent să adăugați funcționalități claselor dvs.
împreună cu datele. Această funcționalitate ia forma unor metode.

56
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Metodele sunt pur și simplu numite proceduri care sunt încorporate în clasa dvs. Când apelați o metodă pe
un obiect, metoda face ceva util, cum ar fi returnarea unor date calculate. În acest exemplu, vom adăuga o
metodă GetHtml() la clasa Produs. Această metodă va returna un șir reprezentând un bloc formatat de
HTML pe baza datelor curente din obiectul Produs. Acest cod HTML include un titlu cu numele produsului,
prețul produsului și un element <img> care arată imaginea produsului asociată. (Veți explora HTML mai
îndeaproape în capitolul 4.)
clasa publică Produs { // (Cod suplimentar de clasă omis
pentru claritate.)

șir public GetHtml() { string htmlString; htmlString = "<h1>" + nume + "</h1><br />"; htmlString += "<h3>Costuri: " +
"Price.ToString() + "</h3><br />"; htmlString += "<img src='" + imageUrl + "' />"; } returnează htmlString; }

Tot ce face metoda GetHtml() este să citească datele private și să le formateze într-un mod atractiv. Puteți
lua acest bloc HTML și plasați-l pe o pagină web pentru a reprezenta produsul. Acest lucru vizează
într-adevăr clasa ca o clasă de interfață cu utilizatorul, mai degrabă decât ca o clasă de date pure sau "obiect
de afaceri".

Adăugarea unui constructor

În prezent, clasa de produse are o problemă. În mod ideal, clasele ar trebui să se asigure că sunt întotdeauna într-o stare
validă. Cu toate acestea, dacă nu setați în mod explicit toate proprietățile corespunzătoare, obiectul Produs nu va corespunde
unui produs valid. Acest lucru poate provoca o eroare dacă încercați să utilizați o metodă care se bazează pe unele date care
nu au fost furnizate. Pentru a rezolva această problemă, trebuie să vă echipați clasa cu una sau mai multe
Constructori.
Un constructor este o metodă care rulează automat atunci când clasa este creată pentru prima dată. În C#,
constructorul are întotdeauna același nume ca și numele clasei. Spre deosebire de o metodă normală,
constructorul nu definește niciun tip de retur, nici măcar nul.
Următorul exemplu de cod arată o nouă versiune a clasei de produse. Adaugă un constructor care necesită
prețul produsului și numele ca argumente:

clasa publică Produs { // (Cod suplimentar de clasă omis

pentru claritate.)

public Product(nume șir, preț zecimal) { // Setați două proprietăți în clasă. Nume = nume; } Preț = preț; }

57
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Iată un exemplu de cod de care aveți nevoie pentru a crea un obiect bazat pe noua clasă de produse, folosind
constructorul său:
Vânzarea produsuluiProdus = produs nou ("Gunoi de bucătărie", 49.99M);
Codul precedent este mult mai flexibil decât codul necesar pentru a crea și inițializa versiunea anterioară a clasei de
produse. Cu ajutorul constructorului, puteți crea un obiect Produs și îl puteți configura cu datele de bază de care are
nevoie într-o singură linie.
Dacă nu creați un constructor, .NET furnizează un constructor public implicit care nu face nimic. În cazul în
care creați cel puțin un constructor, .NET nu va furniza un constructor implicit. Astfel, în exemplul
precedent, clasa de produse are exact un constructor, care este cel definit în mod explicit în cod. Pentru a
crea un obiect Produs, trebuie să utilizați acest constructor. Această restricție împiedică un client să creeze
un obiect fără a specifica cantitatea minimă de date necesare:
Acest lucru nu va fi permis, deoarece nu există un
constructor cu argument zero. Vânzarea
produsuluiProdus = Produs nou();
Descărcați de la Wow! eBook <www.wowebook.com>

Notă Pentru
• deoarece a creasă
încearcă o instanță
utilizeze aununei clase, trebuie
constructor să utilizați
cu argument un care
zero, constructor. Codul
nu există precedent nu reușește
în clasa
Produs.

Majoritatea claselor pe care le utilizați vor avea constructori care necesită parametri. Ca și în cazul
metodelor obișnuite, constructorii pot fi supraîncărcați cu mai multe versiuni, fiecare oferind un set
diferit de parametri.
clasa publică Produs { // (Cod suplimentar de clasă omis
pentru claritate.)

public Product(nume șir, preț zecimal) { Name =

name; Preț = preț; }

public Product(nume șir, preț zecimal, șir imageUrl) { Name = nume; Preț = preț; } ImageUrl = imageUrl; }

Când creați un obiect, puteți alege constructorul care vi se potrivește cel mai bine pe baza
informațiilor pe care le aveți la dispoziție. Clasele .NET Framework utilizează pe scară largă
constructori supraîncărcați.

58
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Adăugarea unui eveniment

Clasele pot utiliza, de asemenea, evenimente pentru a vă notifica codul. Pentru a defini un eveniment în C#,
trebuie mai întâi să creați un delegat care definește semnătura pentru evenimentul pe care îl veți utiliza. Apoi
puteți defini un eveniment pe baza acelui delegat folosind cuvântul cheie al evenimentului. Ca și în cazul
proprietăților și metodelor, evenimentele pot fi declarate cu diferite accesibilități, deși evenimentele publice
sunt implicite. De obicei, aceasta este ceea ce doriți, deoarece veți utiliza evenimentele pentru a permite unui
obiect să notifice un alt obiect care este o instanță a unei clase diferite. Ca exemplu, exemplul clasei de
produse a fost îmbunătățit cu un eveniment PriceChanged care are loc ori de câte ori prețul este modificat
prin procedura proprietății Price. Acest eveniment nu se va declanșa dacă codul din interiorul clasei modifică
variabila de preț privat subiacentă fără a trece prin procedura proprietății:
Definiți delegatul care reprezintă evenimentul. delegat public nul PriceChangedEventHandler();

clasa publică Produs { // (Cod suplimentar de clasă omis

pentru claritate.)

Definiți evenimentul folosind delegatul.

eveniment public PriceChangedEventHandler PriceChanged;
preț zecimal public { get { preț dus; } set { preț = valoare;

Concediați evenimentul, cu condiția să existe cel puțin un ascultător. dacă (PriceChanged != null) {
PriceChanged();

}}
}
}
Pentru a declanșa un eveniment, trebuie doar să-i spui pe nume. Cu toate acestea, înainte de a declanșa un eveniment,
trebuie să verificați dacă există cel puțin un abonat, testând dacă referința evenimentului este nulă. Dacă nu este nul,
este sigur să declanșați evenimentul.
Este foarte posibil să creați zeci de aplicații ASP.NET fără a defini o dată un eveniment personalizat. Cu toate
acestea, veți fi greu să scrieți o singură pagină web ASP.NET fără a gestiona un eveniment. Pentru a
gestiona un eveniment, creați mai întâi o metodă numită rutină de tratare a evenimentelor. Rutina de tratare a
evenimentelor conține codul care trebuie executat atunci când are loc evenimentul. Apoi, conectați rutina de
tratare a evenimentelor la eveniment. Pentru a gestiona evenimentul Product.PriceChanged, trebuie să
începeți prin a crea un operator de evenimente, pe care îl veți plasa de obicei într-o altă clasă. Rutina de
tratare a evenimentelor trebuie să aibă aceeași semnătură ca și evenimentul pe care îl gestionează. În
exemplul de produs, evenimentul PriceChanged nu are parametri, astfel încât rutina de tratare a
evenimentelor ar arăta ca metoda simplă prezentată aici:

59
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

public void ChangeDetected() { // Acest cod se execută ca răspuns la

evenimentul PriceChanged. }

Următorul pas este să conectați operatorul evenimentului la eveniment. Pentru aceasta, utilizați o
instrucțiune simplă de atribuire care setează evenimentul (PriceChanged) la metoda de gestionare a
evenimentelor (ChangeDetected) utilizând operatorul +=:
Vânzarea produsuluiProdus = produs nou ("Gunoi de bucătărie", 49.99M);

Aceasta conectează evenimentul saleProduct.PriceChanged la o procedură de

gestionare a evenimentului // numită ChangeDetected.
Rețineți că ChangedDetected trebuie să se potrivească cu delegatul
PriceChangedEventHandler //.
saleProduct.PriceChanged += ChangeDetected;

Acum evenimentul va avea loc ca răspuns la acest cod:

saleProduct.Price = saleProduct.Price * 2;
Acest cod atașează o rutină de tratare a evenimentelor la o metodă numită ChangeDetected. Această metodă este în
aceeași clasă cu codul de conectare a evenimentelor afișat aici și, din acest motiv, nu este necesar să specificați numele
obiectului atunci când atașați rutina de tratare a evenimentelor. Dacă doriți să conectați un eveniment la un alt obiect, va
trebui să utilizați sintaxa punctelor atunci când faceți referire la metoda rutinei de tratare a evenimentelor, ca în
myObject.ChangeDetected.
Este demn de remarcat faptul că, dacă utilizați Visual Studio, nu va trebui să conectați manual gestionarii de
evenimente pentru controale web. În schimb, Visual Studio poate adăuga codul de care aveți nevoie pentru a
conecta toate rutinele de tratare a evenimentelor pe care le creați.
ASP.NET folosește un model de programare bazat pe evenimente, astfel încât în curând vă veți obișnui să
scrieți cod care reacționează la evenimente. Dar, dacă nu vă creați propriile componente, nu va trebui să
declanșați propriile evenimente personalizate. Pentru un exemplu în care evenimentele personalizate au
sens, consultați capitolul 11, care prezintă modul în care puteți adăuga un eveniment la un control de utilizator
pe care l-ați creat.

• Sfat: De asemenea, puteți detașa o rutină de tratare a evenimentelor utilizând operatorul -= în loc de +=.

Testarea clasei de produse

Pentru a afla mai multe despre modul în care funcționează clasa de produse, vă ajută să creați o pagină web
simplă. Această pagină web va crea un obiect Produs, va obține reprezentarea HTML și apoi îl va afișa în
pagina web. Pentru a încerca acest exemplu, va trebui să utilizați cele trei fișiere furnizate împreună cu
mostrele online din folderul Capitol03\Site web:
• Product.cs: Acest fișier conține codul pentru clasa de produse. Se află în
subfolderul Chapter03\Website\App_Code, care ASP.NET permite să îl
compilați automat.
• Garbage.jpg: Aceasta este imaginea pe care o va utiliza clasa de produse.
• Default.aspx: Acest fișier conține codul paginii web care utilizează clasa de produse.

60
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Cel mai simplu mod de a testa acest exemplu este să utilizați Visual Studio. Iată pașii de care aveți nevoie
pentru a efectua testul:
1. Porniți Visual Studio.
2. Selectați File
￫ Open Web Site din
meniu.
3. În Deschideți site-ul web caseta de dialog, navigați la Capitolul 03 dosar, faceți
dublu clic pe el, selectați folderul Site web din interior și faceți clic pe Deschis.
4. Alegeți
→ Debugfără depanare pentru a lansa site-ul web. Visual Studio va deschide o
Începeți
fereastră nouă cu browserul implicit și va naviga la pagina Default.aspx.

Când pagina Default.aspx se execută, creează un nou obiect Produs, îl configurează și utilizează metoda
GetHtml(). Codul HTML este scris pe pagina web folosind metoda Response.Write(). Iată codul:

<%@ Page Language="C#" %> <script runat="server"> private void Page_Load(object sender,
EventArgs e) { Product saleProduct = new Product("Kitchen Garbage", 49.99M, "garbage.jpg");
Response.Write(saleProduct.GetHtml()); } </script>

<html> <head> <title>test produs</title>

</head> <body></body> </html>

Blocul <script> utilizează setarea atributului runat="server" pentru a rula codul pe serverul web, nu în
browserul web al utilizatorului. Blocul <script> conține o subrutină numită Page_Load. Această subrutină
este declanșată la prima creare a paginii. Odată ce acest cod este terminat, codul HTML este trimis
clientului. Figura 3-2 arată pagina web pe care o veți vedea.

61
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Figura 3-2. Ieșire generată de un obiect Produs

Interesant este că metoda GetHTML () este similară cu modul în care funcționează un control web ASP.NET, dar la
un nivel mult mai brut. Pentru a utiliza un control ASP.NET, creați un obiect (explicit sau implicit) și configurați unele
proprietăți. Apoi, ASP.NET creează automat o pagină web examinând toate aceste obiecte și solicitând codul HTML
asociat (apelând o metodă ascunsă GetHtml() sau făcând ceva conceptual similar1). Apoi trimite pagina finalizată
utilizatorului. Rezultatul final este că lucrați cu obiecte, în loc să vă ocupați direct de codul HTML brut.

Când utilizați un control web, vedeți numai interfața publică formată din proprietăți, metode și evenimente.
Cu toate acestea, înțelegerea modului în care funcționează de fapt codul de clasă vă va ajuta să stăpâniți
dezvoltarea avansată.

1
De fapt, motorul ASP.NET apelează o metodă numită Render() în fiecare control web.

62
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Acum că ați văzut elementele de bază ale cursurilor și o demonstrație a modului în care puteți utiliza o clasă,
este timpul să introduceți puțin mai multă teorie despre obiectele .NET și să revizuiți tipurile de date de bază
introduse în capitolul anterior.

Tipuri de valori și tipuri de referință

În capitolul 2, ați învățat cum tipurile de date simple, cum ar fi șirurile și numerele întregi, sunt de fapt obiecte create din
biblioteca clasei. Acest lucru permite câteva trucuri impresionante, cum ar fi manipularea încorporată a șirurilor și
calcularea datei. Cu toate acestea, tipurile de date simple diferă de obiectele mai complexe într-un mod important.
Tipurile de date simple sunt tipuri de valori, în timp ce clasele sunt tipuri de referință.
Aceasta înseamnă că o variabilă pentru un tip simplu de date conține informațiile reale pe care le introduceți
în ea (cum ar fi numărul 7). Pe de altă parte, variabilele obiectului stochează de fapt o referință care indică o
locație în memorie unde este stocat întregul obiect. În cele mai multe cazuri, .NET vă maschează de această
realitate de bază, iar în multe sarcini de programare nu veți observa diferența. Cu toate acestea, în trei cazuri
veți observa că variabilele obiectului acționează puțin diferit față de tipurile de date obișnuite: în operațiile de
atribuire, în operațiile de comparație și la trecerea parametrilor.

Operațiuni de atribuire
Când atribuiți o variabilă de date simplă unei alte variabile simple de date, conținutul variabilei este copiat:

integerA = întregB; integerA are acum o copie a conținutului întregB. Există două numere
întregi duplicate în memorie.

Tipurile de referință funcționează puțin diferit. Tipurile de referință tind să se ocupe de cantități mai mari de
date. Copierea întregului conținut al unui obiect de tip referință poate încetini o aplicație, în special dacă
efectuați mai multe atribuiri. Din acest motiv, atunci când atribuiți un tip de referință, copiați referința care
indică spre obiect, nu întregul conținut al obiectului:
Creați un nou obiect Produs.
Produsul produsuluiVariabila1 = produs nou ("Gunoi de bucătărie", 49,99M);

Declarați o a doua variabilă. Produsul

produsuluiVariabilă2; productVariable2 =
productVariable1;
productVariable1 și productVariable2 indică acum același lucru. Există un obiect și
două modalități de a-l accesa.
Consecințele acestui comportament sunt foarte variate. Acest exemplu modifică obiectul Produs utilizând
productVariable2:
productVariable2.Price = 25.99M;
Veți găsi că productVariable1.Price este, de asemenea, setat la 25.99. Desigur, acest lucru are sens doar
pentru că productVariable1 și productVariable2 sunt două variabile care indică același obiect din memorie.
Dacă doriți cu adevărat să copiați un obiect (nu o referință), trebuie să creați un obiect nou și apoi să inițializați informațiile
sale pentru a se potrivi cu primul obiect. Unele obiecte oferă o metodă Clonare() care vă permite să copiați cu ușurință

63
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

obiectul. Un exemplu este setul de date, care este utilizat pentru a stoca informații dintr-o bază de date.

Testarea egalității
O distincție similară între tipurile de referință și tipurile de valori apare atunci când comparați două variabile.
Când comparați tipurile de valori (cum ar fi numerele întregi), comparați conținutul:

if (integerA == integerB) { // Acest lucru este adevărat atâta timp cât

numerele întregi au același conținut. }

Când comparați variabilele tipului de referință, testați de fapt dacă sunt aceeași instanță. Cu alte
cuvinte, testați dacă referințele indică același obiect în memorie, nu dacă conținutul lor se potrivește:

dacă (productVariable1 == productVariable2) { // Acest lucru este adevărat dacă atât productVariable1 cât și productVariable2
indică același lucru.

Acest lucru este fals dacă sunt obiecte separate, dar identice. }

Notă Această regulă are o excepție specială. Când clasele suprascriu operatorul ==, pot schimba ce tip de
•
comparația pe care o efectuează. Singurul exemplu semnificativ al acestei tehnici în .NET
este clasa String. Pentru mai multe informații, citiți secțiunea "Revizuirea tipurilor .NET" din
continuarea acestui capitol.

Trecerea parametrilor după referință și valoare

Puteți crea trei tipuri de parametri de metodă. Tipul standard este pass-by-value. Când utilizați parametri
pass-by-value, metoda primește o copie a datelor parametrilor. Asta înseamnă că dacă metoda modifică
parametrul, această modificare nu va afecta codul de apelare. În mod implicit, toți parametrii sunt valori de trecere.

Al doilea tip de parametru este pass-by-reference. Cu pass-by-reference, metoda accesează direct valoarea
parametrului. Dacă o metodă modifică valoarea unui parametru pass-by-reference, obiectul original este, de asemenea,
modificat.
Pentru a înțelege mai bine diferența, luați în considerare următorul cod, care arată o metodă care utilizează
un parametru numit număr. Acest cod utilizează cuvântul cheie ref pentru a indica faptul că numărul trebuie
transmis prin referință. Când metoda modifică acest parametru (înmulțindu-l cu 2), codul de apelare este, de
asemenea, afectat:
vid privat ProcessNumber(ref int number) {
number *= 2; }

64
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Următorul fragment de cod arată efectul apelării metodei ProcessNumber. Rețineți că trebuie să specificați
cuvântul cheie ref atunci când definiți parametrul în metodă și când apelați metoda. Acest lucru indică
faptul că sunteți conștient de faptul că valoarea parametrului se poate modifica:
num int = 10; ProcessNumber(num ref); După finalizarea acestui apel, Num va fi 20.

Dacă nu includeți cuvântul cheie ref, veți primi o eroare atunci când încercați să compilați codul. Modul în care
funcționează pass-by-value și pass-by-reference atunci când utilizați tipuri de valori (cum ar fi numere întregi) este
simplu. Cu toate acestea, dacă utilizați tipuri de referință, cum ar fi un obiect Produs sau o matrice, nu veți vedea
acest comportament. Motivul este că întregul obiect nu este trecut în parametru. În schimb, este doar referința care
este transmisă. Acest lucru este mult mai eficient pentru obiectele mari (economisește necesitatea de a copia un
bloc mare de memorie), dar nu duce întotdeauna la comportamentul pe care îl așteptați. O ciudățenie notabilă apare
atunci când utilizați mecanismul standard de trecere cu valoare. În acest caz, pass-by-value nu creează o copie a
obiectului, ci o copie a referinței. Această referință indică încă același obiect din memorie. Aceasta înseamnă că,
dacă transmiteți un obiect Produs unei metode, de exemplu, metoda va putea modifica obiectul Produsului,
indiferent dacă utilizați referință pass-by-value sau pass-by-reference. (Singura limitare este că, dacă utilizați
pass-by-value, nu veți putea Modificați referința - de exemplu, înlocuiți obiectul cu unul complet nou pe care îl
creați.) C# acceptă, de asemenea, un al treilea tip de parametru: parametrul de ieșire. Pentru a utiliza un parametru
de ieșire, precedați declarația parametrului cu cuvântul cheie afară. Parametrii de ieșire sunt utilizați în mod obișnuit
ca o modalitate de a returna mai multe informații dintr-o singură metodă.
Când utilizați parametri de ieșire, codul de apelare poate trimite o variabilă neinițializată ca parametru, care
altfel este interzisă. Această abordare nu ar fi adecvată pentru metoda ProcessNumber(), deoarece citește
valoarea parametrului trimis (și apoi o dublează). Dacă, pe de altă parte, metoda a folosit parametrul doar
pentru a returna informații, puteți utiliza cuvântul cheie, așa cum se arată aici:

private void ProcessNumber(int number, int doubled, out int tripled)

out { dublat = număr * 2; triplat = număr * 3; }

Rețineți că parametrii de ieșire sunt concepuți exclusiv pentru metoda de returnare a informațiilor către
codul de apelare. De fapt, metoda nu va fi permisă pentru a prelua valoarea unui parametru out, deoarece
poate fi neinițializată. Singura acțiune pe care o poate lua metoda este setarea parametrului de ieșire. Iată
un exemplu despre cum puteți apela metoda ProcessNumber () reînnoită:
int num = 10; int dublat, triplat;
ProcessNumber(num , out doubled, out tripled);

Revizuirea tipurilor .NET

Până în prezent, discuția s-a concentrat pe tipuri și clase de date simple. Biblioteca de clase .NET este de fapt
compusă din tipuri, care este un termen general care include mai multe rude asemănătoare obiectelor:

Clase: Acesta este cel mai comun tip din .NET Framework. Șirurile și matricele sunt două exemple de
clase .NET, deși vă puteți crea cu ușurință propriile clase.

65
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Structuri: Structurile, cum ar fi clasele, pot include câmpuri, proprietăți, metode și evenimente. Spre deosebire de
clase, ele sunt tipuri de valori, ceea ce modifică modul în care se comportă cu operațiile de atribuire și comparație.
Structurilor le lipsesc, de asemenea, unele dintre caracteristicile clasei mai avansate (cum ar fi moștenirea) și sunt,
în general, mai simple și mai mici. Numerele întregi, datele și caracterele sunt toate structuri.
Enumerări: O enumerare definește un set de constante întregi cu nume descriptive.
Enumerările au fost introduse în capitolul anterior.
Delegați: Un delegat este un indicator de funcție care vă permite să invocați indirect o procedură. Delegații
sunt fundamentul pentru gestionarea evenimentelor .NET și au fost introduși în capitolul anterior.
Interfețe: Acestea definesc contractele la care o clasă trebuie să adere. Interfețele sunt o tehnică
avansată de programare orientată pe obiecte și sunt utile atunci când se standardizează modul în care
interacționează obiectele. Interfețele nu sunt discutate în această carte.

Ocazional, o clasă își poate suprascrie comportamentul pentru a acționa mai mult ca un tip de valoare. De exemplu, tipul
Șir este o clasă cu caracteristici complete, nu un tip de valoare simplu. (Acest lucru este necesar pentru a face șirurile
eficiente, deoarece acestea pot conține o cantitate variabilă de date.) Cu toate acestea, tipul String suprascrie
operațiunile sale de egalitate și atribuire, astfel încât aceste operațiuni să funcționeze ca cele ale unui tip de valoare
simplu. Acest lucru face ca tipul String să funcționeze în modul în care programatorii se așteaptă intuitiv. Matricele, pe de
altă parte, sunt tipuri de referință prin și prin. Dacă atribuiți o variabilă matrice alteia, copiați referința, nu matricea (deși
clasa Matrice oferă, de asemenea, o metodă Clonare() care returnează o matrice dublată pentru a permite copierea
adevărată).
Tabelul 3-2 stabilește înregistrarea și explică câteva tipuri comune.

Tabelul 3-2. Tipuri comune de referință și valori

Tip de date Natură Comportament

Int32, zecimal, simplu, dublu și toate
celelalte tipuri numerice de bază
DateTime, TimeSpan
Tip valoare Operațiunile de egalitate și atribuire
funcționează cu conținutul variabil, nu cu o
referință.
Tip valoare Operațiunile de egalitate și atribuire funcționează
cu conținutul variabil, nu cu o referință.

Char, Byte și Boolean Tip valoare Operațiunile de egalitate și atribuire funcționează

cu conținutul variabil, nu cu o referință.

Șir Tip de referință Operațiile de egalitate și atribuire par să

funcționeze cu conținutul variabilei, nu cu o
referință.

Matrice Tip de referință Operațiunile de egalitate și atribuire

funcționează cu referința, nu cu conținutul.

66
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII
3 DE NUME

Înțelegerea spațiilor de nume și a ansamblurilor

Indiferent dacă vă dați seama la început, fiecare bucată de cod din .NET există în interiorul unui tip .NET
(de obicei o clasă). La rândul său, fiecare tip există în interiorul unui spațiu de nume. Figura 3-3 prezintă
acest aranjament pentru propriul cod și clasa DateTime. Rețineți că aceasta este o simplificare extremă -
numai spațiul de nume al sistemului este stocat cu câteva sute de clase. Această diagramă este proiectată
numai pentru a vă arăta straturile de organizare.

Figura 3-3. O privire asupra a două spații de nume

Spațiile de nume pot organiza toate tipurile diferite din biblioteca clasei. Fără spații de nume, aceste tipuri
ar fi grupate într-o singură listă lungă și dezordonată. Acest tip de organizare este practic pentru un set mic
de informații, dar ar fi nepractic pentru miile de tipuri incluse în .NET. Multe dintre capitolele din această
carte vă prezintă noi clase și spații de nume .NET. De exemplu, în capitolele despre controalele web, veți
învăța cum să utilizați obiectele din spațiul de nume System.Web.UI. În capitolele despre serviciile web, veți
studia tipurile din spațiul de nume System.Web.Services. Pentru bazele de date, veți apela la spațiul de
nume System.Data. De fapt, ați învățat deja puțin despre un spațiu de nume: spațiul de nume de bază al
sistemului care conține toate tipurile simple de date explicate în capitolul anterior.
Pentru a continua explorarea după ce ați terminat cartea, va trebui să apelați la referința Ajutor Visual Studio, care
documentează minuțios proprietățile, metodele și evenimentele fiecărei clase din fiecare spațiu de nume. Dacă aveți Visual
Studio instalat, puteți vizualiza ajutorul Visual Studio selectând Pornire toate programele Microsoft Visual Studio 2010
→ 2010 Documentation (calea exactă depinde de ￫versiunea MicrosoftdeVisual
VisualStudio
Studio pe care ați instalat-o).
Sau puteți vizualiza referința bibliotecii clasei în browserul preferat la http://tinyurl.com/2d42w5e (consultați
Figura 3-4).
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3
Descărcați de la Wow! eBook <www.wowebook.com>

Figura 3-4. Referința bibliotecii de clase online

Pentru a răsfoi referința bibliotecii de clase, începeți prin a alege un spațiu de nume din partea stângă a
paginii (cum ar fi System.Web.UI). Când faceți acest lucru, pagina afișează o listă cu toate clasele din acel
spațiu de nume, așa cum se arată în Figura 3-4. Apoi, apasă pe numele unei clase (cum ar fi Pagina). Acum,
pagina afișează o prezentare generală a clasei Paginii și linkuri suplimentare care vă permit să vizualizați
diferitele tipuri de membri ai clasei. De exemplu, apasă pe Proprietăți Pagină pentru a revizui toate
proprietățile clasei Pagină sau apasă pe Evenimente din Pagină pentru a-i explora evenimentele.
Utilizarea spațiilor de nume
Adesea, atunci când scrieți ASP.NET cod, veți utiliza doar spațiul de nume pe care Visual Studio îl creează
automat. Dacă, totuși, doriți să vă organizați codul în mai multe spații de nume, puteți defini spațiul de nume
utilizând o structură simplă de blocuri, așa cum se arată aici:
namespace Compania mea {
namespace MyApp { public
class Produs { } } // Codul merge
aici.

68
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

}
În exemplul precedent, clasa Product se află în spațiul de nume MyCompany.MyApp. Codul din acest spațiu de
nume poate accesa clasa de produse după nume. Codul din afara acestuia trebuie să utilizeze numele complet
calificat, ca în MyCompany.MyApp.Product. Acest lucru vă asigură că puteți utiliza componentele de la diferiți
dezvoltatori terți fără să vă faceți griji cu privire la o coliziune de nume. Dacă acești dezvoltatori respectă
standardele de denumire recomandate, clasele lor vor fi întotdeauna într-un spațiu de nume care utilizează numele
companiei și al produsului software. Numele complet calificat al unei clase va fi aproape sigur unic.

Spațiile de nume nu iau un cuvânt cheie de accesibilitate și pot fi imbricate oricâte straturi adâncime aveți
nevoie. Imbricarea este pur cosmetică - de exemplu, în exemplul anterior, nu există nicio relație specială
între spațiul de nume Compania mea și spațiul de nume MyApp. De fapt, puteți crea spațiul de nume
MyCompany.MyApp fără a utiliza deloc cuibărirea folosind această sintaxă:
namespace MyCompany.MyApp { public class Product { // Codul merge aici. } }

Puteți declara același spațiu de nume în diferite fișiere de cod. De fapt, mai multe proiecte pot utiliza chiar
același spațiu de nume. Spațiile de nume nu sunt altceva decât un container convenabil, logic, care vă ajută
să vă organizați cursurile.

Importul spațiilor de nume

Necesitatea de a tasta nume lungi, complet calificate, vă va obosi cu siguranță degetele și va crea un cod prea detaliat.
Pentru a strânge codul, este o practică standard să importați spațiile de nume pe care doriți să le utilizați. Când importați
un spațiu de nume, nu este necesar să tastați numele complet calificat. În schimb, puteți utiliza tipurile din acel spațiu de
nume ca și cum ar fi definite local.
Pentru a importa un spațiu de nume, utilizați instrucțiunea de utilizare. Aceste instrucțiuni trebuie să
apară ca primele linii în fișierul de cod, în afara spațiilor de nume sau a structurilor de blocuri:
folosind MyCompany.MyApp;
Luați în considerare situația fără a importa un spațiu de nume:
MyCompany.MyApp.Product salesProduct = nou Companiamea.MyApp.Product(...);
Este mult mai ușor de gestionat atunci când importați spațiul de nume Companiamea.MyApp. După ce
faceți acest lucru, puteți utiliza în schimb această sintaxă:
Vânzări de produseProdus = Produs nou(...);
Importul spațiilor de nume este într-adevăr doar o comoditate. Nu are niciun efect asupra performanței
aplicației dvs. De fapt, indiferent dacă utilizați importuri de spațiu de nume, codul IL compilat va arăta la fel.
Acest lucru se datorează faptului că compilatorul de limbă va traduce referințele relative ale clasei în nume de
clase complet calificate atunci când generează un fișier EXE sau DLL.

69
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

CREARE SIMPLIFICATĂ A OBIECTELOR

Chiar dacă alegeți să nu importați un spațiu de nume, puteți comprima orice instrucțiune care declară o
variabilă obiect și o instanțiază. Trucul este să folosiți cuvântul cheie var despre care ați aflat în capitolul 2.

De exemplu, puteți înlocui această afirmație:

MyCompany.MyApp.Product salesProduct = nou MyCompany.MyApp.Product();
Cu aceasta:
salesProduct = nou Companiamea.MyApp.Product();
Var
Acest lucru funcționează deoarece compilatorul poate determina tipul de date corect pentru variabila
salesProduct pe baza obiectului pe care îl creați cu noul cuvânt cheie. Cel mai bine, această afirmație
este la fel de lizibilă ca și abordarea non-var, deoarece este încă clar ce tip de obiect creați.
Desigur, această tehnică nu va funcționa dacă compilatorul nu poate determina tipul de obiect dorit.
Din acest motiv, niciuna dintre aceste afirmații nu este permisă:
var salesProductInvalid1; var
salesProductInvalid2 = null;
În plus, trucul var este limitat la variabilele locale. Nu îl puteți utiliza atunci când
declarați variabilele membre ale unei clase.

Ansambluri
S-ar putea să vă întrebați ce vă oferă posibilitatea de a utiliza spațiile de nume ale bibliotecii de clasă într-un
program .NET. Sunt conectate direct în limbă? Adevărul este că toate clasele .NET sunt conținute în
ansambluri. Ansamblurile sunt fișierele fizice care conțin cod compilat. De obicei, fișierele de asamblare au
extensia .exe dacă sunt aplicații independente sau .dll dacă sunt componente reutilizabile.

• Sfat: Extensia .dll este utilizată și pentru codul care trebuie executat (sau găzduit) de un alt tip
de program. Când aplicația web este compilată, aceasta este transformată într-un fișier DLL,
deoarece codul nu reprezintă o aplicație independentă. În schimb, motorul ASP.NET îl execută
atunci când se primește o solicitare web.

Nu există o relație strictă între ansambluri și spații de nume. Un ansamblu poate conține mai multe spații de nume. În
schimb, mai multe fișiere de asamblare pot conține clase în același spațiu de nume. Din punct de vedere tehnic,
spațiile de nume sunt o modalitate logică de grupare a claselor. Cu toate acestea, ansamblurile sunt un pachet fizic
pentru distribuirea codului.
Clasele .NET sunt de fapt conținute într-un număr de ansambluri. De exemplu, tipurile de bază din spațiul de nume Sistem
provin din ansamblul mscorlib.dll. Multe tipuri ASP.NET se găsesc în ansamblul System.Web.dll. În plus, poate doriți să utilizați
alte ansambluri terțe. Adesea, ansamblurile și spațiile de nume au aceleași nume. De exemplu, veți găsi spațiul de nume
System.Web în fișierul de asamblare System.Web.dll. Cu toate acestea, aceasta este o comoditate, nu o cerință. Când
compilați o aplicație, trebuie să spuneți compilatorului de limbă ce ansambluri utilizează aplicația. În mod implicit, o gamă largă

70
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

de ansambluri .NET sunt puse automat la dispoziția ASP.NET aplicații. Dacă trebuie să utilizați ansambluri suplimentare,
trebuie să le definiți într-un fișier de configurare pentru site-ul dvs. Visual Studio face acest proces fără probleme,
permițându-vă să adăugați referințe de asamblare la fișierul de configurare utilizând site-ul web

→ comanda Adăugare referință. Veți utiliza comanda Adăugare referință din capitolul 22.

Programare avansată de clasă

O parte din arta programării orientate pe obiecte este determinarea relațiilor dintre obiecte. De exemplu, puteți crea un
obiect Produs care conține un obiect ProductFamily sau un obiect Car care conține patru obiecte Wheel. Pentru a crea
acest tip de relație obiect, tot ce trebuie să faceți este să definiți variabila sau proprietățile corespunzătoare din clasă.
Acest tip de relație se numește izolare (sau agregare).
De exemplu, următorul cod afișează o clasă ProductCatalog, care conține o matrice de obiecte Product:

clasă publică ProductCatalog {

Produse private[] produse;

(Alt cod de clasă merge aici.) }

În programarea ASP.NET, veți găsi clase speciale numite colecții care nu au alt scop decât gruparea
diferitelor obiecte. Unele colecții vă permit, de asemenea, să sortați și să recuperați obiecte folosind un nume
unic. În capitolul anterior, ați văzut un exemplu cu ArrayList din spațiul de nume System.Collections, care
oferă o matrice redimensionabilă dinamic. Iată cum puteți utiliza ArrayList pentru a modifica clasa
ProductCatalog:
clasă publică ProductCatalog {

produse private ArrayList = nou ArrayList();

(Alt cod de clasă merge aici.) }

Această abordare are avantaje și dezavantaje. Facilitează adăugarea și eliminarea elementelor din listă, dar
elimină, de asemenea, un nivel util de verificare a erorilor, deoarece ArrayList acceptă orice tip de obiect.
Veți afla mai multe despre această problemă mai târziu în acest capitol (în secțiunea "Generice"). În plus,
clasele pot avea un alt tip de relație cunoscută sub numele de moștenire.

Moștenire
Moștenirea este o formă de reutilizare a codului. Permite unei clase să dobândească și să extindă funcționalitatea unei
alte clase. De exemplu, puteți crea o clasă numită Produs taxabil care moștenește (sau derivă) din Produs. Clasa
TaxableProduct ar câștiga toate aceleași câmpuri, metode, proprietăți și evenimente ale clasei de produse. (Cu toate
acestea, nu ar moșteni constructorii.) Apoi puteți adăuga membri suplimentari care se referă la impozitare.

Iată un exemplu care adaugă o proprietate doar în citire numită TotalPrice:

71
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

clasa publică TaxableProduct : Produs {

private zecimal taxRate = 1.15M;

zecimal public TotalPrice { get { // Codul poate accesa proprietatea Price deoarece este // o parte publică a clasei de bază
Produs.

Cu toate acestea, codul nu poate accesa variabila prețului privat. } } returnare (Price *

taxRate);

Creați un constructor cu trei argumente care apelează constructorul cu trei argumente // din clasa
Produs.
public TaxableProduct(nume șir, preț zecimal, șir imageUrl) : base(nume, preț,
imageUrl) { } }

Există un rid interesant în acest exemplu. Cu moștenirea, constructorii nu sunt niciodată moșteniți. Cu toate acestea,
aveți nevoie în continuare de o modalitate de a inițializa detaliile moștenite (în acest caz, acestea sunt proprietățile
Nume, Preț și ImageUrl).
Singura modalitate de a rezolva această problemă este să adăugați un constructor în clasa derivată
(TaxableProduct) care apelează constructorul potrivit din clasa de bază (Product) folosind cuvântul cheie de bază.
În exemplul anterior, clasa TaxableProduct utilizează această tehnică. Acesta include un singur constructor care
necesită cele trei argumente familiare și apelează constructorul corespunzător cu trei argumente din clasa Product
pentru a inițializa proprietățile Name, Price și ImageUrl. Constructorul TaxableProduct nu conține niciun cod
suplimentar, dar ar putea; De exemplu, îl puteți utiliza pentru a inițializa alte detalii specifice clasei derivate.
Moștenirea este mai puțin utilă decât v-ați putea aștepta. Într-o aplicație obișnuită, majoritatea claselor folosesc
conținerea și alte relații în loc de moștenire, deoarece moștenirea poate complica viața inutil, fără a oferi multe
beneficii. Dan Appleman, un renumit programator .NET, a descris odată moștenirea ca fiind "cea mai tare
caracteristică pe care nu o vei folosi aproape niciodată".
Cu toate acestea, veți vedea moștenirea la locul de muncă în ASP.NET în cel puțin un loc. Moștenirea vă permite să
creați o clasă particularizată care moștenește caracteristicile unei clase din biblioteca de clase .NET. De exemplu, atunci
când creați un formular web particularizat, moșteniți de fapt de la o clasă de pagini de bază pentru a obține setul
standard de caracteristici.
Există mult mai multe subtilități ale programării bazate pe clasă cu moștenire. De exemplu, aveți posibilitatea
să suprascrieți părți ale unei clase de bază, să împiedicați moștenirea claselor sau să creați o clasă care
trebuie utilizată pentru moștenire și nu poate fi creată direct. Cu toate acestea, aceste subiecte nu sunt
acoperite în această carte și nu sunt necesare pentru a construi aplicații ASP.NET. Pentru mai multe
informații despre aceste caracteristici lingvistice, consultați o carte mai detaliată care acoperă limbajul C#,
cum ar fi Andrew Troelsen's Pro C# 2010 și .NET 4 Platform (Apress, 2010).

72
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Membri statici
Începutul acestui capitol a introdus ideea de proprietăți și metode statice, care pot fi utilizate fără un obiect viu.
Elementele statice sunt adesea folosite pentru a oferi funcționalități utile legate de un obiect. Biblioteca de clase
.NET folosește foarte mult această tehnică (ca și în cazul clasei System.Math explorată în capitolul anterior).

Membrii statici au o mare varietate de utilizări posibile. Uneori oferă conversii de bază și funcții utilitare care
acceptă o clasă. Pentru a crea o proprietate sau o metodă statică, trebuie doar să utilizați cuvântul cheie static
imediat după cuvântul cheie de accesibilitate.
Următorul exemplu prezintă o clasă TaxableProduct care conține o proprietate statică TaxRate și o
variabilă privată. Aceasta înseamnă că există o copie a informațiilor privind rata de impozitare și se aplică
tuturor obiectelor TaxableProduct:
clasa publică TaxableProduct : Produs { // (Cod
suplimentar de clasă omis pentru claritate.)

impozit zecimal static privat = 1,15M;

Acum puteți apela TaxableProduct.TaxRate, chiar și fără un obiect. zecimal static

public TaxRate { get { return taxRate; } set { taxRate = value; } } }

Acum puteți prelua informațiile despre rata de impozitare direct din clasă, fără a fi nevoie să creați mai întâi
un obiect:
Modificați rata de impozitare. Acest lucru va afecta toate calculele TotalPrice pentru orice obiect
// TaxableProduct.
TaxableProduct.TaxRate = 1.24M;

Datele statice nu sunt legate de durata de viață a unui obiect. De fapt, este disponibil pe toată durata de viață
a întregii aplicații. Aceasta înseamnă că membrii statici sunt cel mai apropiat lucru pe care programatorii .NET
îl au de datele globale. Un membru static nu poate accesa un membru al instanței. Pentru a accesa un
membru nonstatic, acesta are nevoie de o instanță reală a obiectului dvs.

Sfat crea o clasă compusă în întregime din membri statici. Doar adăugați cuvântul cheie
• Puteți
static la declarație, ca în cele ce urmează:

clasa statică publică TaxableUtil

Când declarați o clasă cu cuvântul cheie static, vă asigurați că nu poate fi instanțiată. Cu toate
acestea, trebuie să utilizați cuvântul cheie static atunci când declarați membri statici în clasa dvs.

73

3
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Turnarea obiectelor
Variabilele de obiect pot fi convertite cu aceeași sintaxă utilizată pentru tipurile de date simple. Acest proces se numește
turnare. Când efectuați turnarea, nu schimbați nimic despre un obiect; de fapt, rămâne exact aceeași pată de date binare
care plutesc undeva în memorie. Ceea ce schimbi este variabila care indică obiectul – cu alte cuvinte, modul în care
codul tău "vede" obiectul. Acest lucru este important, deoarece modul în care codul vede un obiect determină ce puteți
face cu acel obiect.
O variabilă obiect poate fi distribuită într-unul din cele trei lucruri: ea însăși, o interfață pe care o acceptă sau o clasă de
bază de la care moștenește. Nu puteți proiecta o variabilă obiect într-un șir sau într-un întreg. În schimb, trebuie să
apelați o metodă de conversie, dacă este disponibilă, cum ar fi ToString() sau Parse().
După cum ați văzut deja, clasa TaxableProduct derivă din Product. Aceasta înseamnă că introduceți o
referință Produs impozabil la o referință de produs, așa cum se arată aici:

Creați un produs impozabil.

TaxableProduct theTaxableProduct = nou TaxableProduct("Kitchen
Garbage", 49.99M, "garbage.jpg");

Proiectați referința TaxableProduct la o referință de produs. Produsul

theProduct = ProdusulTaxabil;
Nu pierdeți nicio informație atunci când efectuați acest casting. Există încă un singur obiect în memorie (cu
două variabile care indică spre el), iar acest obiect este într-adevăr un produs impozabil. Cu toate acestea,
atunci când utilizați variabila theProduct pentru a accesa obiectul TaxableProduct, veți fi limitat la proprietățile
și metodele definite în clasa Produs. Asta înseamnă că un astfel de cod nu va funcționa:
Acest cod generează o eroare de compilare. zecimal
TotalPrice = theProduct.TotalPrice;

Chiar dacă Produsul deține de fapt o referință care indică un Produs Taxabil și chiar dacă Produsul Taxabil are o
proprietate Preț Total, nu îl puteți accesa prin intermediul Produsului. Acest lucru se datorează faptului că Produsul
tratează obiectul la care se referă ca fiind un Produs obișnuit.
De asemenea, puteți proiecta în direcția inversă - de exemplu, proiectați o referință de produs la o referință
Produs impozabil. Trucul aici este că acest lucru funcționează numai dacă obiectul care este în memorie
este într-adevăr un produs impozabil. Acest cod este corect:
Produsul theProduct = nouTaxableProduct(...); TaxableProduct
theTaxableProduct = (TaxableProduct)theProduct;

Dar acest cod generează o eroare de execuție:

Produs theProduct = nou ;

Produs(...)
TaxableProduct theTaxableProduct = (TaxableProduct)theProduct;

• Notă Când proiectați un obiect dintr-o clasă de bază într-o clasă derivată, ca în acest exemplu,
trebuie să utilizați sintaxa explicită de distribuire despre care ați aflat în capitolul 2. Aceasta
înseamnă că plasați tipul de date între paranteze înaintea variabilei pe care doriți să o proiectați.
Aceasta este o garanție menită să sublinieze faptul că are loc turnarea. Este necesar deoarece
această operațiune de turnare ar putea eșua.

74
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

De altfel, puteți verifica dacă aveți tipul potrivit de obiect înainte de a încerca să proiectați cu ajutorul
cuvântului cheie:

dacă (theProduct is TaxableProduct) { // Este

sigur să aruncați referința.

TaxableProduct theTaxableProduct = (TaxableProduct)theProduct; }

O altă opțiune este cuvântul cheie as, care încearcă să proiecteze un obiect la tipul pe care îl solicitați, dar
returnează o referință nulă dacă nu poate (în loc să provoace o eroare de execuție). Iată cum funcționează:

Produsul theProduct = nouTaxableProduct(...); Produs taxabil

theTaxableProduct = Produsul ca TaxableProduct; dacă
(theTaxableProduct != null) { // (Este sigur să utilizați obiectul.)

} else { // (Fie conversia a eșuat, fie theTaxableProduct a fost nul de la început.) }

Rețineți că această abordare poate pur și simplu să amâne problema, înlocuind o eroare imediată de
turnare cu o eroare de referință nulă mai târziu în codul dvs., când încercați să utilizați obiectul nul. Cu
toate acestea, puteți utiliza această tehnică în același mod în care utilizați cuvântul cheie - pentru a
arunca un obiect dacă este posibil sau doar pentru a continua dacă nu este.

Notădintre motivele pentru care se utilizează proiectarea este pentru a facilita un cod mai
• Unul
reutilizabil. De exemplu, puteți proiecta o aplicație care utilizează obiectul Produs. Această
aplicație este de fapt capabilă să gestioneze o instanță a oricărei clase derivate din produs.
Aplicația dvs. nu trebuie să facă distincția între toate clasele derivate diferite (TaxableProduct,
NonTaxableProduct, PromoProduct și așa mai departe); Poate funcționa perfect cu toate.

În acest moment, s-ar putea părea că posibilitatea de a converti obiecte este o tehnică destul de specializată, care va fi
necesară numai atunci când utilizați moștenirea. Acest lucru nu este întotdeauna adevărat. Conversiile obiectelor sunt,
de asemenea, necesare atunci când utilizați unele clase deosebit de flexibile.
Un exemplu este clasa ArrayList introdusă în capitolul anterior. ArrayList este proiectat astfel încât să poată
stoca orice tip de obiect. Pentru a avea această abilitate, tratează toate obiectele în același mod - ca
instanțe ale clasei rădăcină System.Object. (Amintiți-vă, toate clasele din .NET moștenesc de la
System.Object la un moment dat, chiar dacă această relație nu este definită explicit în codul clasei.)
Rezultatul final este că atunci când regăsiți un obiect dintr-o colecție ArrayList, trebuie să îl proiectați dintr-un
System.Object la tipul său real, așa cum se arată aici:
Creați ArrayList.
Produse ArrayList = nou ArrayList();

Adăugați mai multe obiecte Produs.

75
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

Produse. Adăugare(produs1);
Produse. Adăugare(produs2);
Produse. Adăugare(produs3);

Recuperați primul element, cu turnare.

Produs recuperatProdus = Produse (Produs)[0];

Acest lucru funcționează.

Response.Write(retrievedProduct.GetHtml());

Recuperați primul element, ca obiect. Acest lucru nu necesită turnare, // dar nu veți
putea utiliza niciuna dintre metodele sau proprietățile produsului. Obiect
preluatObiect = produse[0];
Acest lucru generează o eroare de compilare. Nu există nicio metodă
Object.GetHtml(). Response.Write(retrievedObject.GetHtml());

După cum puteți vedea, dacă nu efectuați turnarea, nu veți putea utiliza metodele și proprietățile
obiectului pe care îl recuperați. Veți găsi multe cazuri ca acesta în codul .NET, în care codul dvs. primește
unul dintre mai multe tipuri posibile de obiecte și depinde de dvs. să aruncați obiectul la tipul corect pentru
a utiliza funcționalitatea sa completă.

Clase parțiale
Clasele parțiale vă oferă posibilitatea de a diviza o singură clasă în mai multe fișiere de cod sursă C# (.cs).
De exemplu, în cazul în care clasa de produse a devenit deosebit de lungă și complexă, ați putea decide să
o împărțiți în două bucăți, așa cum se arată aici:
Această parte este stocată în fișierul Product1.cs. public
clasa parțială Produs { șir public Nume {
get; set; }

eveniment public PriceChangedEventHandler

PriceChanged; preț zecimal privat; preț zecimal public { get
{ preț dus; } set { preț = valoare;

Concediați evenimentul, cu condiția să existe cel puțin un ascultător.

if (PriceChanged != null) { PriceChanged(); } șir public ImageUrl {
get; set;}

}
}

76
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

public Product(nume șir, preț zecimal, șir imageUrl) { Name = nume; Preț = preț; } ImageUrl = imageUrl;

Această parte este stocată în fișierul Product2.cs. public

Clasa Produs
{parțial
șir public GetHtml() { string htmlString; htmlString = "<h1>" + Nume + "</h1><br
/>"; htmlString += "<h3>Costuri: " + "Price.ToString() + "</h3><br />"; htmlString
+= "<img src='" + ImageUrl + "' />"; returnare htmlString; } }

O clasă parțială se comportă la fel ca o clasă normală. Aceasta înseamnă că fiecare metodă, proprietate și
variabilă pe care le-ați definit în clasă sunt disponibile oriunde, indiferent de fișierul sursă care le conține. Când
compilați aplicația, compilatorul urmărește fiecare piesă a clasei de produse și o asamblează într-o unitate
completă. Nu contează cum denumiți fișierele codului sursă, atâta timp cât păstrați numele clasei consecvent.

Clasele parțiale nu oferă prea multe în ceea ce privește rezolvarea problemelor de programare, dar pot fi utile
dacă aveți clase extrem de mari și greoaie. Scopul real al claselor parțiale din .NET este de a ascunde codul
de designer generat automat prin plasarea acestuia într-un fișier separat de codul dvs. Visual Studio
utilizează această tehnică atunci când creați pagini web pentru o aplicație web și formulare pentru o aplicație
Windows.

• Notă Fiecare fragment dintr-o clasă parțială trebuie să utilizeze cuvântul cheie parțial în declarația de clasă.

Generice
Genericele sunt o caracteristică mai subtilă și mai puternică decât clasele parțiale. Genericele vă permit să creați clase
care sunt parametrizate după tip. Cu alte cuvinte, creați un șablon de clasă care acceptă orice tip. Când instanțiați acea
clasă, specificați textul pe care doriți să îl utilizați și, din acel moment, obiectul este "blocat" la tipul pe care l-ați ales.

Pentru a înțelege cum funcționează acest lucru, este mai ușor să luați în considerare unele dintre clasele .NET care acceptă
generice. În capitolul anterior (și mai devreme în acest capitol), ați văzut cum clasa ArrayList vă permite să creați o colecție de
dimensiuni dinamice care se extinde pe măsură ce adăugați elemente și se micșorează pe măsură ce le eliminați. Cu toate
acestea, ArrayList are o slăbiciune - acceptă orice tip de obiect. Acest lucru îl face extrem de flexibil, dar înseamnă, de
asemenea, că puteți întâmpina din greșeală o eroare. De exemplu, imaginați-vă că utilizați un ArrayList pentru a urmări un
catalog de produse. Intenționați să utilizați ArrayList pentru a stoca obiecte Produs, dar nu există nimic care să împiedice o

77
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII DE NUME
3

bucată de cod care nu se comportă corect să insereze șiruri, numere întregi sau orice obiect arbitrar în ArrayList. Iată un
exemplu:

Creați ArrayList.
Produse ArrayList = nou ArrayList();

Adăugați mai multe obiecte Produs.

Produse. Adăugare(produs1);
Produse. Adăugare(produs2);
Produse. Adăugare(produs3);
Observați cum puteți adăuga în continuare alte tipuri la ArrayList. Produse.
Add("Acest șir nu aparține aici.");

Soluția este o nouă clasă de colectare a listelor. La fel ca ArrayList, clasa List este suficient de flexibilă
pentru a stoca obiecte diferite în diferite scenarii. Dar, deoarece acceptă generice, îl puteți bloca într-un
anumit tip ori de câte ori instanțiați un obiect Listă. Pentru aceasta, specificați clasa pe care doriți să o
utilizați între paranteze unghiulare după numele clasei, așa cum se arată aici:
Creați Lista pentru stocarea obiectelor Produs.
Listă<Produs> produse = listă nouă<produs>();

Acum puteți adăuga numai obiecte de produs la colecție:

Adăugați mai multe obiecte Produs.

Produse. Adăugare(produs1);
Produse. Adăugare(produs2);
Produse. Adăugare(produs3);
Această linie nu reușește. De fapt, nici măcar nu se va
compila. Produse. Add("Acest șir nu poate fi inserat.");

Pentru a afla dacă o clasă utilizează generice, căutați parantezele înclinate. De exemplu, clasa listă este
listat ca listă<T> în documentația .NET Framework pentru a sublinia faptul că este nevoie de un parametru
de tip. Puteți găsi această clasă și multe alte colecții care utilizează generice în spațiul de nume
System.Collections.Generic. (ArrayList original se află în spațiul de nume System.Collections.)

Notă că ați văzut avantajul clasei Listă, s-ar putea să vă întrebați de ce .NET include deloc
• Acum
ArrayList. Într-adevăr, ArrayList este încă util dacă într-adevăr trebuie să stocați diferite tipuri de
obiecte într-un singur loc (ceea ce nu este teribil de comun). Cu toate acestea, răspunsul real
este că genericele nu au fost implementate în .NET până la versiunea 2.0, astfel încât multe
clase existente nu le folosesc din cauza compatibilității înapoi.

De asemenea, puteți crea propriile clase care sunt parametrizate după tip, cum ar fi colecția Listă. Crearea
de clase care utilizează generice depășește scopul acestei cărți, dar puteți găsi o imagine de ansamblu
solidă la http://tinyurl.com/39sa5q3 dacă sunteți încă curioși.

78
 CAPITOLUL TIPURI, OBIECTE ȘI SPAȚII
3 DE NUME

Ultimul cuvânt
La modul cel mai simplu, programarea orientată pe obiecte este ideea că codul dvs. ar trebui să fie
organizat în clase separate. Dacă este urmată cu atenție, această abordare duce la un cod mai ușor de
modificat, îmbunătățit, depanat și reutilizat. Acum că știți elementele de bază ale programării orientate pe
obiecte, puteți face un tur al instrumentului de dezvoltare ASP.NET premier: Visual Studio.

• Notă: În cele două capitole anterioare, ați învățat elementele esențiale despre C# și
programarea orientată pe obiecte. Limbajul C# continuă să evolueze și există multe caracteristici
lingvistice mai avansate pe care nu le-ați văzut în aceste două capitole. Dacă doriți să continuați
explorarea C# și să deveniți un guru al limbajului, puteți vizita Microsoft C# Developer Center
online la http://msdn.microsoft.com/vcsharp sau puteți consulta o carte mai aprofundată despre C#,
cum ar fi excelentul și foarte aprofundatul Pro C# 2010 și Platforma .NET 4 (Apress, 2010).
PART2

• ■■

Dezvoltarea
aplicațiilor ASP.NET
CAPITOLUL4

• ■■

Visual Studio

În vremurile antice ale programării web, dezvoltatorii au creat pagini web cu editori de text simpli, cum ar fi Notepad. Alte
opțiuni erau disponibile, dar fiecare suferea de propriile ciudățenii și limitări. Standardul a fost o abordare fără mănuși a
HTML brut, cu blocuri de cod inserate ori de câte ori este necesar. Visual Studio schimbă toate acestea. În primul rând,
este extensibil și poate funcționa chiar și în tandem cu editorii web, cum ar fi Microsoft Expression Web sau Adobe
Dreamweaver. Cu alte cuvinte, puteți face codificarea grea cu Visual Studio, dar utilizați un alt instrument de design web
pentru a face totul să arate frumos. În al doilea rând, Visual Studio include caracteristici indispensabile de economisire a
timpului. De exemplu, vă oferă posibilitatea de a trage și plasa pagini web în existență și de a depana codul care se
comportă greșit. Visual Studio include chiar și un server web de testare încorporat, care vă permite să creați și să testați
un site web complet ASP.NET fără să vă faceți griji cu privire la configurarea unui server web real.

În acest capitol, veți învăța cum să creați o aplicație web folosind Visual Studio. Pe parcurs, veți arunca o privire la
anatomia unui formular web ASP.NET și veți revizui elementele esențiale ale XHTML. Veți afla, de asemenea, cum
IntelliSense poate reduce dramatic numărul de erori pe care le veți face și cum să utilizați legendarul depanator într-un
singur pas al Visual Studio pentru a privi sub capotă și a vă "urmări" programul în acțiune. Până la sfârșitul acestui capitol,
veți fi bine familiarizați cu cel mai important instrument din setul de instrumente al oricărui dezvoltator ASP.NET (Visual
Studio) și veți înțelege principiile de bază ale dezvoltării web cu
ASP.NET.

Promisiunea Visual Studio

Toate aplicațiile .NET sunt construite din fișiere sursă cu text simplu. Codul VB este stocat în fișiere .vb, iar codul
C# este stocat în fișiere .cs, indiferent dacă acest cod este proiectat pentru o aplicație Windows autonomă sau
pentru Web. În ciuda acestui fapt, rareori veți găsi dezvoltatori VB sau C # care creează aplicații Windows manual
într-un editor de text. Procesul nu este doar obositor, ci deschide și ușa către o serie de posibile erori pe care un
instrument de proiectare le-ar putea prinde cu ușurință. Același lucru este valabil și pentru programatorii ASP.NET.
Deși puteți scrie clasele de pagini web și puteți codifica manual comenzile paginii web, veți petrece ore întregi
dezvoltând și testând codul. În schimb, este logic să folosiți una dintre numeroasele ediții ale Visual Studio.
Visual Studio este un instrument indispensabil pentru dezvoltatorii de pe orice platformă. Acesta oferă mai
multe beneficii impresionante:

Verificarea integrată a erorilor: Visual Studio poate detecta o gamă largă de probleme, cum ar fi erori
de conversie a tipurilor de date, spații de nume sau clase lipsă și variabile nedefinite. Pe măsură ce
tastați, erorile sunt detectate, subliniate și adăugate la o listă de erori pentru referință rapidă.
Proiectantul de formulare web: Pentru a crea o pagină web în Visual Studio, pur și simplu glisați
ASP.NET controale în locația corespunzătoare și le configurați proprietățile. Visual Studio efectuează
ridicarea grea și creează automat marcajul real al paginii web.

83
 CAPITOLUL VISUAL STUDIO
4

Un server web integrat: Pentru a executa o aplicație web ASP.NET, aveți nevoie de un server web care
execută software-ul de server web Internet Information Services (IIS). Serverul web are o sarcină simplă -
așteaptă solicitările browserului și servește paginile corespunzătoare. Configurarea unui server web nu este
dificilă, dar este incomodă. Datorită serverului web de dezvoltare integrat în Visual Studio, puteți rula un site
web direct din mediul de proiectare. (Desigur, va trebui totuși să implementați aplicația pe un server web real
când este terminată, așa cum veți vedea în capitolul 26.)
Îmbunătățiri ale productivității dezvoltatorilor: Visual Studio face codificarea rapidă și eficientă, cu un
afișaj de cod pliabil, completarea automată a instrucțiunilor și sintaxa codificată prin culori. Puteți crea
chiar și programe macro sofisticate care automatizează sarcinile repetitive.
Depanare cu granulație fină: Depanatorul integrat al Visual Studio vă permite să urmăriți executarea
codului, să întrerupeți programul în orice moment și să inspectați conținutul oricărei variabile. Aceste
instrumente de depanare pot salva dureri de cap nesfârșite atunci când scrieți rutine complexe de cod.
Extensibilitate completă: Puteți să utilizați macrocomenzi, să modificați șabloanele de proiect și chiar
să adăugați propriile programe de completare particularizate la Visual Studio. Și chiar dacă nu
intenționați să utilizați singur aceste funcții, este posibil să doriți totuși să utilizați utilități terțe la
îndemână care depind de ele.

• Notă Sfaturile și tehnicile pe care le învățați în acest capitol vor funcționa la fel de bine cu toate
versiunile de Visual Studio, inclusiv cu Visual Web Developer Express gratuit.

Crearea de site-uri web

Porniți Visual Studio selectând Start ￫ Toate programele ￫ Microsoft Visual Studio 2010 Microsoft
→ (Figura 4-1).
Visual Studio 2010. Când Visual Studio se încarcă pentru prima dată, afișează pagina de pornire

84
 CAPITOLUL VISUAL
4 STUDIO

Figura 4-1. Pagina de pornire Visual Studio

Pagina de pornire include o listă de aplicații deschise recent. Puteți face clic pe un link din această listă pentru a vă relua
rapid lucrul de unde ați rămas ultima dată. Pagina de pornire include, de asemenea, linkuri către conținutul dezvoltatorului
online de pe site-ul Web Microsoft Developer Network (MSDN). Deși sunteți liber să ignorați acest conținut, s-ar putea să
găsiți un articol interesant, un exemplu de cod la îndemână sau un supliment inteligent pe care veți dori să îl încercați.
(Dacă obiceiurile dvs. de navigare sunt puțin mai tradiționale, puteți găsi același conținut online. Un bun punct de plecare
este comunitatea ASP.NET de la http://www.asp.net.)
Pentru a face ceva practic cu Visual Studio, trebuie să creați o aplicație web. Următoarele secțiuni vă
arată cum.

Crearea unei aplicații web goale

Pentru a crea prima aplicație Visual Studio, urmați acești pași:
1. Selectați Fișier
￫ Site Web nou din meniul Visual Studio. Noul site web
→ caseta de dialog (prezentată în Figura
4-2) va apărea.
 CAPITOLUL VISUAL STUDIO
4

Figura 4-2. Caseta de dialog Site Web nou

2. În lista din stânga, alegeți limba pe care doriți să o utilizați pentru a vă scrie codul.

Notă Limbajul de programare este doar o valoare implicită - puteți adăuga de fapt pagini web Visual Basic la un C#
•
și puteți adăuga pagini C# la un site web VB.

3. În lista derulantă din partea de sus a ferestrei, alegeți versiunea de .NET pe care
doriți să o utilizați. De obicei, veți alege .NET Framework 4. Cu toate acestea,
utilizați Visual Studio pentru a crea, de asemenea, aplicații web care sunt
proiectate pentru versiuni mai vechi de .NET, până la .NET 2.0.
4. În lista de șabloane din mijlocul ferestrei, alegeți tipul de aplicație pe care doriți
să o creați. Pentru moment, cea mai bună opțiune este ASP.NET site web gol,
care nu va aglomera site-ul dvs. web o grămadă de fișiere și setări pregenerate.
Pentru mai multe informații despre diferențele dintre șabloanele de site-uri web
Visual Studio, consultați bara laterală "Șabloane de site-uri web".

86
 CAPITOLUL VISUAL STUDIO
4

ȘABLOANE DE SITE-URI WEB

Visual Studio poate crea diferite tipuri de aplicații ASP.NET folosind diferite șabloane. Indiferent de
șablonul pe care îl alegeți, site-ul dvs. web este compilat și executat în același mod. Singura diferență
este fișierele pe care Visual Studio le creează în mod implicit.
Iată o descriere a opțiunilor de șablon:
ASP.NET site web: Acest lucru creează un site web ASP.NET cu funcții complete, cu
infrastructura sa de bază deja implementată. Acest site web include o pagină coordonatoare
care definește aspectul general (cu antet, subsol și bara de meniu) și două pagini web gata
făcute, denumite default.aspx și about.aspx. De asemenea, include un folder Conturi cu
pagini pentru înregistrare, conectare și schimbarea parolei.
ASP.NET Site web gol: Acest lucru creează un site web aproape gol. Acesta include un fișier de
configurare web.config decupat și nimic altceva. Desigur, este ușor să completați piesele de care
aveți nevoie pe măsură ce începeți codificarea.
ASP.NET Date dinamice: Aceasta creează un site web ASP.NET care utilizează caracteristica
Date dinamice ASP.NET. Există de fapt două șabloane de date dinamice, care utilizează abordări
ușor diferite pentru comunicarea cu baza de date. Deși datele dinamice nu sunt discutate în
această carte, puteți afla despre ele în Pro ASP.NET 4.0 în C# 2010.
Serviciul WCF: Acest lucru creează un serviciu WCF - o bibliotecă de metode pe partea de
server pe care clienții la distanță (de exemplu, aplicațiile Windows) le pot apela.
ASP.NET Reports Web Site: Aceasta creează un site Web ASP.NET care utilizează controlul
ReportView și SQL Server Reporting Services (un instrument pentru generarea rapoartelor bazei
de date care pot fi vizualizate și gestionate pe Web). Șablonul site-ului Web ASP.NET Crystal
Reports oferă un serviciu similar, dar utilizează software-ul concurent Crystal Reports.
Deși majoritatea dezvoltatorilor preferă să înceapă cu șablonul ASP.NET Empty Web Site sau ASP.NET
Web Site și să înceapă codificarea, există încă șabloane mai specializate pentru anumite tipuri de aplicații
web. Pentru a le vizualiza, faceți clic pe titlul Șabloane online din extremitatea stângă a casetei de dialog
Site Web nou. Va exista o scurtă întârziere în timp ce Visual Studio contactează serverele web Microsoft,
după care va adăuga o listă de subcategorii de șabloane, fiecare cu propriul grup de șabloane gata făcute.

5. Alegeți o locație pentru site-ul web. Locația specifică unde vor fi stocate fișierele
site-ului web. De obicei, veți alege Sistem de fișiere, apoi veți utiliza un folder pe
computerul local. Puteți introduce manual un director în caseta de text Locație și
puteți trece direct la pasul 7. Alternativ, puteți face clic pe butonul Răsfoire, care
afișează caseta de dialog Alegeți locația (consultați Figura 4-3) discutată la pasul
6.

87
 CAPITOLUL VISUAL STUDIO
4
Descărcați de la Wow! eBook <www.wowebook.com>

Figura 4-3. Caseta de dialog Alegere locație

6. Folosind Alegeți locația caseta de dialog, navigați la directorul în care doriți să

plasați site-ul web. Adesea, veți dori să creați un nou director pentru aplicația dvs.
Pentru aceasta, selectați directorul în care doriți să plasați subdirectorul, faceți clic
pe pictograma Creare folder nou (aflată chiar deasupra colțului din dreapta sus al
arborelui de directoare), tastați un nume pentru noul folder și apăsați Enter. În
orice caz, după ce ați selectat directorul, faceți clic pe Deschidere. Caseta de
dialog Alegere locație are, de asemenea, opțiuni (reprezentate de butoanele din
stânga) pentru crearea unei aplicații web într-un director virtual IIS sau pe un
server web la distanță. Puteți ignora aceste opțiuni pentru moment. În general,
este mai ușor să vă dezvoltați aplicația web local și să încărcați fișierele odată ce
sunt perfecte.
Sfat: rețineți că locația în care vă creați site-ul web probabil nu este locul în care îl veți pune atunci când implementați
•
el. Nu vă faceți griji cu privire la acest rid - în capitolul 26 veți învăța cum să luați site-ul dvs. de
dezvoltare și să-l puneți pe un server web live, astfel încât să poată fi accesibil altora printr-o rețea
sau pe Internet.

88
 CAPITOLUL VISUAL STUDIO
4

7. Faceți clic pe OK pentru a crea site-ul web. În acest moment, Visual Studio
generează un nou site web cu un singur fișier, numit web.config. Acesta este un
fișier de configurare în care puteți plasa diverse setări care influențează modul în
care funcționează aplicația dvs. Veți folosi fișierul de configurare pe parcursul
acestei cărți și îi veți acorda o atenție deosebită în capitolul 5.
Acum aveți un nou site web simplu și sunteți gata să începeți proiectarea primei pagini web. Dar, înainte de a
merge mai departe, poate doriți să aflați mai multe despre modul în care Visual Studio ține evidența fișierelor
site-ului web utilizând proiecte (opțional) și soluții. Următoarele două secțiuni au toate detaliile.

Site-uri web și proiecte web

De obicei, Visual Studio utilizează fișiere de proiect pentru a stoca informații despre aplicațiile pe care le creați.
Aplicațiile web sunt puțin neobișnuite, deoarece Visual Studio nu creează neapărat fișiere de proiect pentru ele. De
fapt, dacă ați urmat pașii din secțiunea anterioară, ați creat un site web nou fără fișier de proiect. Acest sistem, care
se numește dezvoltare fără proiect, este diferit de modul în care Visual Studio funcționează cu alte tipuri de aplicații,
cum ar fi componente independente și programe Windows. Este conceput pentru a menține directorul site-ului dvs.
curat și ordonat și, prin urmare, pentru a simplifica implementarea aplicației dvs. web. În acest fel, când este în
sfârșit timpul să încărcați site-ul dvs. web pe un server web live, puteți copia întregul folder fără să vă faceți griji cu
privire la excluderea fișierelor care sunt utilizate numai în scopuri de dezvoltare. Dezvoltarea fără proiect este, de
asemenea, utilă dacă programați cu o echipă de colegi, deoarece puteți lucra fiecare pe pagini separate, fără a fi
nevoie să sincronizați fișierele de proiect și soluție. Pentru majoritatea dezvoltatorilor web, acesta este tot ce trebuie
să știți. Cu toate acestea, există de fapt o altă opțiune: dezvoltare bazată pe proiecte sau proiecte web. Proiectele
web sunt modalitatea originală de a crea aplicații web ASP.NET și sunt încă acceptate în Visual Studio 2010.
Puteți crea un proiect web alegând Fișier nou Proiect și apoi alegând șablonul ASP.NET Aplicație web
sau făcând clic pe linkul Proiect nou de pe Pagina de pornire. Proiectele web acceptă aceleași caracteristici
ca și site-urile web fără proiect, dar utilizează un fișier de proiect suplimentar (cu extensia .csproj). Fișierul
proiectului web ține evidența paginilor web, a fișierelor de configurare și a altor resurse care sunt considerate
parte a aplicației dvs. Este stocat în același director ca toate paginile web și fișierele de cod.
Există câteva motive pentru care ați lua în considerare utilizarea proiectelor web:
• Aveți un proiect web vechi care a fost creat într-o versiune de Visual Studio înainte
de Visual Studio 2005. Când deschideți acest proiect în Visual Studio 2010, acesta va
fi migrat automat ca proiect web pentru a evita ciudățeniile ciudate de compatibilitate
care altfel ar putea apărea.
• Doriți să plasați două (sau mai multe) proiecte web în același folder al site-ului web. Din
punct de vedere tehnic, ASP.NET va considera aceste două proiecte ca fiind o singură
aplicație web. Cu toate acestea, cu proiectele web, aveți flexibilitatea de a lucra separat la
fișiere în Visual Studio. Pur și simplu adăugați fișierele pe care doriți să le grupați
împreună la proiectul dvs.
• Aveți un site web foarte mare, care are o mulțime de fișiere de resurse (de exemplu,
mii de imagini). Chiar dacă aceste fișiere fac parte din site-ul dvs. web, este posibil să
nu doriți să apară în fereastra Explorer soluții din Visual Studio, deoarece pot încetini
mediul de dezvoltare. Dacă utilizați proiecte web, puteți rezolva cu ușurință această
problemă - pur și simplu nu adăugați aceste fișiere de resurse la proiectul dvs.

89
 CAPITOLUL VISUAL STUDIO
4

• Doriți să utilizați caracteristica pachetului web Visual Studio sau utilitarul MSBuild pentru a
automatiza modul în care aplicația web este implementată pe un server web. De exemplu,
o companie mare ar putea concepe o strategie de construire care semnează automat
fișierele de aplicații web compilate și le implementează pe un server web de producție. Veți
lua în considerare elementele de bază ale implementării site-ului web în capitolul 26.
Toate exemplele prezentate în această carte folosesc modelul site-ului web fără proiect. Cu toate acestea,
sunteți liber să creați proiecte web dacă vă încadrați într-unul dintre scenariile descrise. Încă scrieți același
cod pentru a vă alimenta paginile web. Este într-adevăr doar o chestiune de gust.

Fișierele soluției ascunse

După cum ați învățat, Visual Studio vă permite să creați aplicații ASP.NET fără fișiere de proiect. Cu toate acestea,
s-ar putea să fiți surprins să aflați că Visual Studio creează încă un tip de fișier de resurse, numit fișier soluție.
Soluțiile sunt un concept similar cu proiectele - diferența este că o singură soluție poate conține unul sau mai multe
proiecte. Ori de câte ori lucrați în Visual Studio, lucrați cu o soluție. Adesea, acea soluție conține un singur site web
fără proiect, dar în scenarii mai avansate ar putea conține de fapt proiecte suplimentare, cum ar fi o aplicație web și
o componentă pe care o utilizați cu site-ul dvs. web. În acest moment, probabil vă întrebați unde plasează Visual
Studio fișierele soluție. Depinde, dar într-o aplicație web tipică fără proiect, Visual Studio ascunde în liniște fișierele
soluției în directorul de documente specific utilizatorului, denumit în această formă:

c:\Utilizatori\[Nume utilizator]\Documente\Visual Studio 2010\Proiecte\[WebsiteFolderName]

Acest sistem poate deveni puțin confuz, deoarece restul fișierelor site-ului dvs. web vor fi plasate într-un
director complet diferit.
Fiecare soluție are două fișiere soluție, cu extensiile de fișiere .sln și .suo. În secțiunea anterioară, a fost
creat un nou site web numit SampleSite. În spatele scenei, Visual Studio generează următoarele fișiere
soluție pentru SampleSite:
SampleSite.sln SampleSite.suo

Când deschideți un site web creat anterior, Visual Studio localizează automat fișierul soluție corespunzător și
utilizează setările din acea soluție.
Fișierele soluție stochează unele detalii specifice Visual Studio care nu sunt direct legate de ASP.NET, cum ar fi
depanarea și setările de vizualizare. De exemplu, Visual Studio urmărește fișierele care sunt deschise în prezent, astfel
încât să le poată redeschide atunci când reluați dezvoltarea site-ului web.
Fișierele soluție nu sunt esențiale. De fapt, dacă mutați site-ul web pe alt computer (sau doar le plasați în altă
locație de pe computer), Visual Studio nu va putea găsi fișierele de soluție originale și veți pierde informațiile
pe care le stochează. De asemenea, puteți întâmpina probleme dacă creați două site-uri web cu același
nume în locații diferite, caz în care fișierele soluție mai noi le pot suprascrie pe cele mai vechi. Cu toate
acestea, deoarece informațiile din fișierele soluție nu sunt chiar atât de importante, pierderea lor nu este o
problemă serioasă. Beneficiile generale ale unui sistem fără proiect merită, de obicei, compromisul.
De obicei, puteți uita complet de soluții și puteți lăsa Visual Studio să le gestioneze fără probleme. Dar, în
unele cazuri, poate doriți să urmăriți mai atent fișierele soluție, astfel încât să le puteți utiliza mai târziu. De
exemplu, poate doriți să utilizați un fișier soluție pentru a deschide o combinație de proiecte la care lucrați
în același timp. Veți vedea această tehnică în acțiune în capitolul 22, când vă dezvoltați propriile
componente.

90
 CAPITOLUL VISUAL STUDIO
4

Exploratorul de soluții
Pentru a arunca o privire de ansamblu asupra site-ului web, puteți utiliza Exploratorul de soluții - fereastra din colțul din
dreapta sus al mediului de proiectare care listează toate fișierele din directorul de aplicații web (consultați Figura 4-4).

Figura 4-4. Exploratorul de soluții

Notă În funcție de setările Visual Studio, poate fi necesar să faceți clic pe fila Explorer soluții din partea dreaptă
•
a ferestrei pentru a o extinde în vizualizare. (Apoi puteți face clic pe pictograma degetul mare din colțul din dreapta sus al Exploratorului
de soluții pentru a o bloca în poziție, astfel încât să fie vizibilă permanent.) Dacă aveți în continuare probleme la găsirea Exploratorului de
soluții, îl puteți convoca oricând în vizualizare prin meniul Visual Studio. Doar alegeți Vizualizare
￫ Explorator de soluții.

Exploratorul de soluții reflectă tot ceea ce se află în directorul de aplicații al unui site web fără proiect. Nu
sunt ascunse fișiere. Aceasta înseamnă că dacă adăugați un fișier HTML simplu, un grafic sau un
subdirector în Windows Explorer, data viitoare când porniți Visual Studio veți vedea conținutul nou în
Exploratorul de soluții. Dacă adăugați aceleași ingrediente în timp ce Visual Studio este deschis, nu le veți
vedea imediat. În schimb, va trebui să reîmprospătați afișajul. Pentru aceasta, faceți clic dreapta pe folderul
site-ului web din Exploratorul de soluții (care apare chiar sub elementul Soluție din partea de sus a arborelui)
și alegeți Reîmprospătare folder. Desigur, întregul scop al Exploratorului de soluții este să vă salveze de la
recurgerea la utilizarea Windows Explorer. În schimb, vă permite să efectuați o varietate de sarcini de
gestionare a fișierelor în Visual Studio. Puteți redenumi, șterge sau copia fișiere făcând clic dreapta pe
element și alegând comanda corespunzătoare.

91
 CAPITOLUL VISUAL STUDIO
4

Atunci când creați un site web nou utilizând șablonul ASP.NET Site Web gol, Exploratorul de soluții începe
ca un loc singuratic, cu nimic mai mult decât un fișier de configurare de bază. Pentru a începe să vă creați
site-ul web, trebuie să adăugați formulare web.

Adăugarea formularelor web

Pe măsură ce vă construiți site-ul web, va trebui să adăugați pagini web noi și alte elemente. Pentru a adăuga aceste ingrediente, alegeți Site web
→ Adăugați element nou din meniul Visual Studio . Când faceți acest lucru, va apărea caseta de dialog
Adăugare element nou.
Puteți adăuga diferite tipuri de fișiere la aplicația web, inclusiv resursele pe care doriți să le utilizați (cum ar fi bitmap-uri),
fișiere HTML obișnuite, fișiere de cod cu definiții de clasă, foi de stil, fișiere de date, fișiere de configurare și multe altele.
Visual Studio oferă chiar și designeri de bază care vă permit să editați majoritatea acestor tipuri de fișiere direct în IDE.
Cu toate acestea, cele mai comune ingrediente pe care le veți adăuga la orice site web sunt formularele web - ASP.NET
paginile web care sunt alimentate cu cod C #.
Pentru a adăuga un formular web, alegeți Formular web în caseta de dialog Adăugare element nou. Veți vedea două
opțiuni suplimentare în colțul din dreapta jos al casetei de dialog Adăugare element nou (așa cum se arată în Figura 4-5).

Figura 4-5. Adăugarea unui formular web ASP.NET

Opțiunea Cod de plasare într-un fișier separat vă permite să alegeți modelul de codificare pentru pagina
Web. Dacă debifați această casetă de selectare, Visual Studio va crea o pagină web cu un singur fișier. Apoi
trebuie să plasați tot codul C# pentru fișier în același fișier care conține marcajul HTML. Dacă selectați
opțiunea Cod de locație într-un fișier separat, Visual Studio va crea două fișiere distincte pentru pagina web,
unul cu marcajul și celălalt pentru codul C#. Aceasta este abordarea mai structurată pe care o veți folosi în
această carte. Avantajul cheie al împărțirii paginii web în fișiere separate este că este mai ușor de gestionat
atunci când trebuie să lucrați cu pagini complexe. Cu toate acestea, ambele abordări vă oferă aceeași
performanță și funcționalitate.

92
 CAPITOLUL VISUAL
4 STUDIO

Veți vedea, de asemenea, o altă opțiune numită Selectare pagină coordonatoare, care vă permite să creați o pagină
care utilizează aspectul pe care l-ați standardizat într-un fișier separat. Pentru moment, ignorați această setare. Veți
învăța cum să creați pagini de master în capitolul 12.
După ce ați ales modelul de codare și ați introdus un nume adecvat pentru pagina dvs. web, faceți clic pe
Adăugare pentru ao crea. Dacă ați ales să utilizați caseta de selectare Cod de locație în fișier separat (care
este recomandată), proiectul dvs. va avea două fișiere pentru fiecare pagină web. Un fișier include marcajul
paginii web (și are extensia de fișier .aspx). Celălalt fișier stochează codul sursă pentru pagină (și utilizează
același nume de fișier, cu extensia de fișier .aspx.cs). Pentru a clarifica relația, Exploratorul de soluții
afișează fișierul de cod sub fișierul .aspx (consultați Figura 4-6).

Figura 4-6. Un fișier de cod pentru o pagină web

• Sfat: Majoritatea site-urilor Web ASP.NET includ o pagină numită Default.aspx, care acționează ca
pagină de pornire a site-ului Web. De obicei, serverele web sunt configurate pentru a afișa pagina de
pornire tuturor vizitatorilor, cu excepția cazului în care specifică în mod explicit o altă pagină în adresa
URL. De exemplu, dacă navigați pe http://www.amazon.com/Beginning-ASP-NET-4-C-2010/dp/1430226080,
Amazon vă arată o pagină de produs pentru o anumită carte. Dar dacă navigați la doar
http://www.amazon.com, veți obține pagina de pornire implicită, care vă poate ghida oriunde trebuie să
mergeți.
De asemenea, puteți adăuga fișiere care există deja selectând Site web Adăugare element existent. Puteți utiliza acest lucru
→ tehnică de copiere a fișierelor de pe un site web pe altul. Visual Studio lasă fișierul original singur și
creează pur și simplu o copie în directorul aplicației web. Cu toate acestea, nu utilizați această abordare cu
o pagină web care a fost creat într-o versiune mai veche de Visual Studio. În schimb, ar trebui să deschideți
întregul site web vechi în Visual Studio 2010, care se asigură că este actualizat corect.

Migrarea unui site web dintr-o versiune anterioară de Visual Studio

Dacă aveți o aplicație web ASP.NET existentă creată cu o versiune anterioară de Visual Studio, o puteți migra cu
ușurință în lumea ASP.NET.
Dacă ați creat un site web fără proiect cu o versiune anterioară de Visual Studio, utilizați fișierul Deschidere
Comanda Site web, la fel cum ați proceda cu un site web creat în Visual Studio 2010. Prima dată→
când tu
→ deschideți un site web mai vechi, veți fi întrebat dacă doriți să îl ajustați pentru a utiliza .NET 4 (consultați
Figura 4-7). Dacă alegeți Da, Visual Studio efectuează o serie de modificări în fișierul de configurare web.config.
Dacă alegeți Nu, site-ul va rămâne așa cum este și va continua să vizeze versiunea mai veche a ASP.NET.
(Puteți modifica acest detaliu în orice moment alegând Site web Opțiuni de pornire.) În orice caz, nu veți fi
 CAPITOLUL VISUAL STUDIO
4

întrebat din nou data viitoare când deschideți site-ul web, deoarece preferința dvs. va fi înregistrată în
fișierul soluție ascuns stocat într-un director Visual Studio specific utilizatorului.

Figura 4-7. Deschiderea unui site web fără proiect care a fost creat cu Visual Studio 2008

Dacă ați creat un proiect web cu o versiune anterioară de Visual Studio, trebuie să utilizați fișierul Deschidere
Comanda Proiect/Soluție. Când faceți acest lucru, Visual Studio începe Expertul de conversie. Cel →
→ Expertul de conversie este extrem de simplu. Vă solicită să alegeți dacă doriți să creați o copie de
rezervă și, dacă da, unde ar trebui plasată (a se vedea figura 4-8). Dacă aceasta este singura copie a
aplicației, o copie de rezervă este o idee bună în cazul în care unele aspecte ale aplicației dvs. nu pot fi
convertite cu succes. În caz contrar, puteți sări peste această opțiune.

Figura 4-8. Importul unui proiect web care a fost creat cu o versiune mai veche de Visual Studio

94
 CAPITOLUL VISUAL STUDIO
4

Când faceți clic pe terminare, Visual Studio efectuează o conversie pe loc, ceea ce înseamnă că suprascrie
fișierele paginii web cu versiunile noi. Toate erorile și avertismentele sunt adăugate într-un jurnal de conversii,
pe care îl puteți afișa după finalizarea conversiei.

MULTITARGETING

Visual Studio acceptă direcționarea multiplă, ceea ce înseamnă că puteți construi aplicații web destinate
pentru .NET 2.0, .NET 3.0, .NET 3.5 sau .NET 4. De obicei, veți alege cea mai recentă versiune
acceptată de serverul dvs. Versiunile ulterioare vă oferă acces la caracteristici mai recente și toate
mostrele care sunt incluse în această carte vizează .NET 4.
Ați văzut deja cum să alegeți versiunea de .NET atunci când creați un site web nou (este lista verticală din
partea de sus a ferestrei). De asemenea, puteți modifica versiunea de .NET pe care o vizați după ce ați
creat site-ul web. Pentru aceasta, urmați acești pași:
1. Alegeți site-ul web ￫ Opțiuni de pornire.
2. În lista din stânga, alegeți categoria Construire.
3. În lista Target Framework, alegeți versiunea de .NET pe care doriți să o vizați.
Când modificați versiunea .NET, Visual Studio modifică fișierul web.config destul de semnificativ. De
exemplu, fișierul web.config pentru o aplicație .NET 4 este scurt și simplificat, deoarece toate instalațiile
sanitare de care are nevoie sunt configurate în fișierul rădăcină web.config al computerului. Dar fișierul
web.config pentru o aplicație .NET 3.5 este destul de dezordonat și plin de boilerplate plictisitoare. (Din
punct de vedere tehnic, acest lucru se datorează faptului că ASP.NET 3.5 a fost lansat ca un fel de
"add-on" la nucleul motorului ASP.NET 2.0.)

Proiectarea unei pagini web

Acum că înțelegeți organizarea de bază a Visual Studio, puteți începe proiectarea unei pagini web simple. Pentru a
începe, în Exploratorul de soluții, faceți dublu clic pe pagina web pe care doriți să o proiectați. (Începeți cu Default.aspx
dacă nu ați adăugat pagini suplimentare.)
Visual Studio vă oferă trei moduri de a privi o pagină .aspx:

Vizualizare proiect: Aici veți vedea o reprezentare grafică a aspectului paginii dvs.
Vizualizare sursă: Aici veți vedea marcajul de bază, cu codul HTML pentru pagină și etichetele de
control ASP.NET.
Vizualizare divizată: Această vizualizare combinată vă permite să vedeți simultan atât vizualizarea
designului, cât și vizualizarea sursă, stivuite una peste cealaltă.

Puteți comuta liber între aceste trei vizualizări făcând clic pe butoanele Proiectare, Scindare și Sursă din partea de jos a
ferestrei proiectantului.
Veți petrece ceva timp în vizualizarea sursă puțin mai târziu în acest capitol, când veți săpa în marcajul
paginii web. Dar mai întâi, este mai ușor să începeți cu vizualizarea mai prietenoasă a designului și să
începeți să adăugați conținut pe pagina dvs.

95
 CAPITOLUL VISUAL STUDIO
4

Sfat: dacă aveți un monitor cu ecran lat, probabil că veți prefera ca vizualizarea divizată să utilizeze două unul lângă altul
• regiuni (mai degrabă decât o regiune de sus și de jos). Din fericire, este ușor să configurați Visual Studio pentru a face acest lucru. Doar selectați Opțiuni instrumente, apoi mergeți la designerul HTML

￫ secțiunea General din arborele setărilor. În cele din urmă, selectați

→ Împărțiți vizualizările pe pictograma
verticală și faceți clic pe OK.

Adăugarea controalelor web

Pentru a adăuga un control web ASP.NET, glisați controlul dorit din Trusa de instrumente din stânga și fixați-l pe pagina
web. Din punct de vedere tehnic, puteți plasa comenzile pe o fereastră de vizualizare a designului sau pe o fereastră de
vizualizare sursă. Cu toate acestea, de obicei, este mai ușor să poziționați controlul în locul potrivit atunci când utilizați
vizualizarea proiect. Dacă plasați comenzile neglijent în vizualizarea sursă, este posibil ca acestea să nu ajungă în
secțiunea <formular>, ceea ce înseamnă că nu vor funcționa în pagina dvs.
Controalele din Toolbox sunt grupate în numeroase categorii pe baza funcțiilor lor, dar veți găsi ingrediente
de bază, cum ar fi butoane, etichete și casete text pe fila Standard.

• Sfat În mod implicit, Toolbox este activat pentru a se ascunde automat atunci când mouse-ul se îndepărtează de el. Acest
comportament este adesea exasperant, așa că vă recomandăm să faceți clic pe degetul mare din colțul din dreapta sus al
Toolbox pentru a-l face să rămână în poziția sa complet extinsă. Iar dacă închideți din greșeală Trusa de instrumente, o puteți
afișa din nou alegând Vizualizare
￫ Toolbox din meniu.

Într-un formular web, controalele sunt poziționate linie cu linie, ca într-un document procesor de text. Puteți
introduce HTML obișnuit sau puteți adăuga controale ASP.NET. Pentru a adăuga un control, trebuie să îl
glisați și să îl fixați într-un loc adecvat. Pentru a organiza mai multe controale în vizualizarea proiect, probabil
că va trebui să adăugați spații și returnări hard (apăsați pe Enter) pentru a poziționa elementele așa cum
doriți. Figura 4-9 prezintă un exemplu cu o casetă de text, o etichetă și un buton.

Figura 4-9. Vizualizarea de proiectare pentru o pagină

96
 CAPITOLUL VISUAL STUDIO
4

Veți descoperi că unele controale nu pot fi redimensionate. În schimb, ele cresc sau se micșorează pentru a se potrivi
cantității de conținut din ele. De exemplu, dimensiunea unui control Etichetă depinde de cantitatea de text pe care o
introduceți în acesta. Pe de altă parte, puteți ajusta dimensiunea unui buton sau a unui control TextBox făcând clic și
trăgând în mediul de proiectare.
Pe măsură ce adăugați controale web la suprafața de proiectare, Visual Studio adaugă automat etichetele de
control corespunzătoare la fișierul .aspx. Pentru a vedea marcajul generat, puteți face clic pe butonul Sursă
pentru a comuta la vizualizarea sursă (sau faceți clic pe butonul Divizare pentru a le vedea pe ambele simultan).
Figura 4-10 arată ce este posibil să vedeți în vizualizarea sursă pentru pagina afișată în Figura 4-9.

Figura 4-10. Vizualizarea sursă pentru o pagină

Folosind vizualizarea sursă, puteți să adăugați manual atribute sau să rearanjați controalele. De fapt, Visual
Studio oferă chiar și caracteristici IntelliSense care completează automat etichetele de deschidere și vă
avertizează dacă utilizați o etichetă nevalidă. Indiferent dacă utilizați designul sau vizualizarea sursă,
depinde în întregime de dvs. - Visual Studio le păstrează pe amândouă sincronizate.

• Notă Când utilizați vizualizarea divizată, Visual Studio păstrează sursa și zona de proiectare
sincronizate. Cu toate acestea, acest proces de sincronizare nu este întotdeauna instantaneu. În
general, dacă efectuați o modificare în regiunea de proiectare, regiunea sursă este actualizată
imediat. Cu toate acestea, dacă efectuați o modificare în regiunea sursă, o bară de mesaje
galbenă apare în partea de sus a regiunii de proiectare pentru a vă avertiza că conținutul s-a
modificat. Pentru a reîmprospăta regiunea de proiectare, pur și simplu faceți clic oriunde în
regiunea de proiectare. Pentru a reîmprospăta regiunea de proiectare fără a lua degetele de pe
tastatură, apăsați Ctrl+S pentru a salva pagina web.

97
 CAPITOLUL VISUAL STUDIO
4

CARACTERISTICA DE ASPECT GRILĂ LIPSĂ

Dacă ați utilizat versiuni vechi de Visual Studio, este posibil să vă amintiți o caracteristică numită aspect grilă, care vă
permitea să poziționați elemente cu coordonate absolute, glisându-le acolo unde doriți. Deși acest model pare
convenabil, într-adevăr nu este potrivit pentru majoritatea paginilor web, deoarece controalele nu își pot ajusta
poziționarea atunci când conținutul paginii web se schimbă (sau când textul este redimensionat pe baza preferințelor
utilizatorului). Acest lucru duce la aspecte inflexibile (cum ar fi controalele care se suprascriu reciproc).

Acestea fiind spuse, Visual Studio are un mod backdoor de a utiliza aspectul grilei. Tot ce trebuie să faceți este să comutați la
vizualizarea sursă și să adăugați un atribut de stil care utilizează CSS pentru a specifica poziționarea absolută. Acest atribut
va exista deja în toate paginile pe care le-ați creat cu o versiune anterioară de Visual Studio .NET în modul de aspect grilă.

Iată un exemplu:
<asp:Button ID="cmd" style="POSITION: absolut; stânga: 100px; sus: 50px;" runat
= "server" text = "buton plutitor" ... />
După ce ați făcut această modificare, sunteți liber să trageți butonul în jurul ferestrei după bunul plac. Desigur,
nu ar trebui să mergeți pe această rută doar pentru că pare mai aproape de modelul Windows. Cele mai multe
Descărcați de la Wow! eBook <www.wowebook.com>

pagini web mari folosesc poziționarea absolută rar, sau deloc, deoarece este prea incomodă și inflexibilă.

Dacă decideți să utilizați poziționarea absolută, cea mai bună idee este să o aplicați pe un recipient, cum ar
fi elementul <div>. Elementul <div> reprezintă o casetă care este invizibilă în mod implicit, dar poate avea
opțional borduri, o umplere de fundal și alte formatări. Folosind poziționarea absolută, puteți plasa apoi
containerul <div> cu precizie, dar lăsați conținutul din interior să utilizeze aspectul normal al fluxului. Acest
lucru simplifică foarte mult cantitatea de aspect pe care trebuie să o faceți. De exemplu, dacă doriți să
creați o bară laterală cu o listă de linkuri, este mult mai ușor să poziționați bara laterală folosind
poziționarea absolută decât să încercați să plasați fiecare link în locul potrivit individual.

Fereastra Proprietăți
După ce ați adăugat un control web la o pagină web, probabil că veți dori să îl modificați puțin. De exemplu,
poate doriți să modificați textul din buton, culoarea unei etichete și așa mai departe. Deși puteți efectua toate
modificările editând manual marcajul sursă, Visual Studio oferă o opțiune mai ușoară. Chiar sub Exploratorul
de soluții, în colțul din dreapta jos al ferestrei Visual Studio, veți vedea fereastra Proprietăți, care vă arată
proprietățile controlului web selectat în prezent și vă permite să le modificați.
Pentru a configura un control în vizualizarea proiect, trebuie mai întâi să îl selectați în pagină (faceți clic pe el o dată în
vizualizarea proiect sau faceți clic undeva în interiorul etichetei pentru acel control în vizualizarea sursă). Veți ști că
este selectat controlul corect atunci când vedeți că numele său apare în lista derulantă din partea de sus a ferestrei
Proprietăți. Alternativ, puteți selecta controlul alegând numele acestuia din lista de ferestre Proprietăți.

După ce ați selectat controlul dorit, puteți modifica oricare dintre proprietățile sale. Cele bune de încercat
includ Text (conținutul controlului), ID (numele pe care îl utilizați pentru a interacționa cu controlul din codul
dvs.) și ForeColor (culoarea utilizată pentru textul controlului).

• Sfat Dacă fereastra Proprietăți nu este vizibilă, o puteți afișa alegând Vizualizare
Fereastra
Proprietăți (sau apăsați
F4).

98
 CAPITOLUL VISUAL STUDIO
4

De fiecare dată când efectuați o selecție în fereastra Proprietăți, Visual Studio ajustează marcajul paginii
web în consecință. Visual Studio oferă chiar și "selectori" speciali care vă permit să selectați proprietăți
extinse. De exemplu, dacă selectați o proprietate de culoare (cum ar fi ForeColor sau BackColor) în
fereastra Proprietăți, un buton cu trei puncte (...) va apărea lângă proprietate, așa cum se arată în
Figura 4-11.

Figura 4-11. Proprietatea ForeColor din fereastra Proprietăți

Dacă faceți clic pe acest buton, Visual Studio va afișa o casetă de dialog în care puteți alege o culoare
particularizată (Figura 4-12). După ce faceți selecția și faceți clic pe OK, Visual Studio va insera codul de
culoare HTML în fereastra Proprietăți și va actualiza marcajul paginii web.

Figura 4-12. Alegerea unei valori de culoare

99
 CAPITOLUL VISUAL STUDIO
4

Veți vedea o caracteristică similară atunci când configurați fonturile. Mai întâi, selectați controlul corespunzător pe
suprafața de proiectare (sau în lista din partea de sus a ferestrei Proprietăți). Apoi, extindeți proprietatea Font din
fereastra Proprietăți și selectați subproprietatea Nume. Lângă proprietate va apărea o săgeată verticală. Faceți clic pe
aceasta pentru a alege dintr-o listă cu toate fonturile instalate pe computer. (Nu înnebuni prea mult aici. Dacă alegeți un
font care nu este instalat pe computerul persoanei care vă vizitează pagina web, browserul va reveni la un font standard.
Capitolul 6 conține mai multe despre alegerea fontului.) Împreună cu controalele web, puteți selecta și etichete HTML
obișnuite în fereastra Proprietăți. Cu toate acestea, există mult mai puține lucruri pe care le puteți face cu ele. Etichetele
HTML obișnuite nu sunt obiecte de programare live, deci nu au caracteristici inteligente pe care le puteți controla. Și
etichetele HTML obișnuite nu oferă multe opțiuni pentru formatare. Dacă doriți să modificați aspectul unei etichete, cea
mai bună alegere este să creați un stil pentru controlul dvs. Dacă sunteți un guru web, puteți face acest lucru manual.
Dacă nu, puteți utiliza caracteristicile de construire a stilului Visual Studio, despre care veți afla în capitolul 12.

În cele din urmă, puteți selecta două obiecte din fereastra Proprietăți care necesită unele explicații - <PAGE>
și DOCUMENT. <PAGE> include o serie de opțiuni ASP.NET care sunt legate de directiva privind paginile -
declarația esențială cu una sau două rânduri care se află în partea de sus a fișierelor .aspx și este descrisă în
secțiunea următoare. Elementul DOCUMENT este mai puțin interesant. Se compune dintr-un set mai mic de
proprietăți, inclusiv un subset al opțiunilor <PAGE> și câteva proprietăți care vă permit să modificați
elementele <title> și <body>.

Anatomia unui formular web

Până acum, v-ați petrecut cea mai mare parte a timpului lucrând cu pagina web în vizualizarea proiect. Nu este nimic
în neregulă cu asta - la urma urmei, facilitează asamblarea rapidă a unei pagini web de bază fără a necesita
cunoștințe HTML.
Cu toate acestea, probabil că nu va dura mult până când vă veți scufunda în vizualizarea sursă. Unele tipuri de
modificări sunt mai ușor de făcut atunci când lucrați direct cu marcajul. Găsirea controlului dorit pe suprafața de
proiectare, selectarea acestuia și editarea proprietăților pe rând în fereastra Proprietăți poate fi obositoare.

Vizualizarea sursă este adesea utilă atunci când doriți să adăugați conținut HTML simplu - la urma urmei, nu
totul din pagina dvs. web trebuie să fie un control web cu drepturi depline. Puteți adăuga elemente HTML
obișnuite utilizând vizualizarea proiect (glisați elementul dorit din fila HTML din Trusa de instrumente), dar
este adesea mai ușor să le tastați manual, deoarece de obicei va trebui să utilizați o combinație de elemente
pentru a obține rezultatul dorit.

Marcajul formularului web

Dacă nu ați scris pagini HTML înainte, sursa paginii web ar putea părea puțin intimidantă. Și dacă ați scris pagini HTML
înainte, sursa paginii web ar putea părea puțin ciudată. Acest lucru se datorează faptului că sursa pentru un formular
web ASP.NET nu este 100% HTML. În schimb, este un document HTML cu un ingredient suplimentar - controale
ASP.NET web.
Fiecare formular web ASP.NET include etichetele HTML standard, cum ar fi <html>, <head> și <body>, care
delimitează secțiunile de bază ale paginii dvs. Puteți insera etichete HTML suplimentare, cum ar fi paragrafe de text
(utilizați eticheta <p>), titluri (utilizați <h1>, <h2>, <h3>), tabele (utilizați <tabel>) și așa mai departe. Împreună cu
HTML standard, puteți adăuga ASP. Elemente numai NET pentru paginile dvs. De exemplu, <asp:Button> reprezintă
un buton pe care se poate face clic care declanșează o activitate pe serverul web. Când adăugați un control web
ASP.NET, creați un obiect cu care puteți interacționa în codul paginii web, ceea ce este extrem de util.

Iată o privire la pagina web prezentată în Figura 4-9. Detaliile care nu fac parte din HTML obișnuit sunt
evidențiate, iar liniile sunt numerotate pentru o referință ușoară:

100
 CAPITOLUL VISUAL
4 STUDIO

1 <%@ Page Language="C#" AutoEventWireup="true"

2CodeFile="Default.aspx.cs" mosteneste="_Default" %>
3 <! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Tranzițional//EN"
4 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

5<html xmlns="http://www.w3.org/1999/xhtml">
6<cap >
runat="server" 7 <titill>Ótitill síðu</titill>
8 </cap>
9 <corp>
10 <form ID="form1" >
runat="server" 11 <div>

12 <asp:Label ID="Label1" runat="server"

13 14
Text="Scrie ceva aici:" /> <br />

15 <asp:TextBox ID="TextBox1" runat="server" />

16 17 <asp:Button ID="Button1" runat="server" Text="Button" /> </div>
18 </mucegai>
19 </corp>
20 </HTML>

Evident, ASP. Detaliile specifice NET (biții evidențiați) nu înseamnă nimic pentru un browser web, deoarece
nu sunt HTML valid. Aceasta nu este o problemă, deoarece browserul web nu vede niciodată aceste detalii.
În schimb, motorul ASP.NET creează un "instantaneu" HTML al paginii dvs. după ce tot codul dvs. a
terminat procesarea pe server. În acest moment, detalii precum <asp:Button> sunt înlocuite cu etichete
HTML care au același aspect. Motorul ASP.NET trimite acest instantaneu HTML către browser.
Acest rezumat este doar o introducere rapidă în ASP.NET model de control web. Veți afla mult mai multe
despre controalele web și despre modul în care funcționează formularele web în culise în următoarele două
capitole. Dar, înainte de a merge mai departe, este important să luați în considerare câteva detalii esențiale
despre formularele ASP.NET web. În secțiunile următoare, veți afla despre directiva paginii (liniile 1 și 2 din
exemplul de cod anterior) și doctype (liniile 3 și 4). Veți face apoi un ocol rapid pentru a revizui unele dintre
regulile esențiale ale XHTML, limbajul de marcare folosit pentru a crea pagini web moderne.

Directiva privind paginile

Pagina Default.aspx, la fel ca toate formularele web ASP.NET, constă din trei secțiuni. Prima secțiune este
directiva paginii:

<%@ Page Language="C#" AutoEventWireup="true"

CodeFile="Default.aspx.cs" mosteneste="_Default" %>

Directiva privind paginile oferă ASP.NET informații de bază despre modul de compilare a paginii. Acesta
indică limba pe care o folosești pentru cod și modul în care conectezi rutinele de tratare a evenimentelor.
Dacă folosiți abordarea code-behind (care este recomandată), directiva privind paginile indică și unde se
află fișierul de cod și numele clasei de pagini personalizate. Nu va trebui să modificați manual directiva
paginii, deoarece Visual Studio o întreține pentru dvs.
 CAPITOLUL VISUAL STUDIO
4

Notă
• Directiva privind pagina este doar pentru ochii ASP.NET. Directiva privind pagina nu apare în
codul HTML trimis browserului - în schimb, ASP.NET o elimină.

Doctipul
Într-o pagină web obișnuită, non-ASP.NET, doctype ocupă prima linie. Într-un formular web ASP.NET, doctype
primește locul al doilea și apare chiar sub directiva paginii.
Doctype indică tipul de marcaj (de exemplu, HTML sau XHTML) pe care îl utilizați pentru a crea pagina web. Din punct
de vedere tehnic, doctype este opțional, dar Visual Studio îl adaugă automat. Acest lucru este important, deoarece, în
funcție de tipul de marcaj pe care îl utilizați, pot exista anumite trucuri care nu sunt permise. De exemplu, XHTML strict
nu vă permite să utilizați caracteristici de formatare HTML care sunt considerate învechite și au fost înlocuite de CSS.

Doctype-ul este, de asemenea, important, deoarece influențează modul în care un browser interpretează
pagina dvs. web. De exemplu, dacă nu includeți un doctype pe pagina web, Internet Explorer (IE) se
comută într-un mod moștenit cunoscut sub numele de mod quirks. În timp ce IE este în modul ciudat,
anumite detalii de formatare sunt procesate în moduri inconsecvente, non-standard, pur și simplu pentru că
acesta este modul istoric în care s-a comportat IE. Versiunile ulterioare ale IE nu încearcă să schimbe acest
comportament, chiar dacă este defect, deoarece unele site-uri web pot depinde de acesta. Cu toate
acestea, puteți specifica o redare mai standardizată care se potrivește mai bine cu comportamentul altor
browsere (cum ar fi Firefox) adăugând un doctype.

Sfat: Dacă aveți o pagină web care arată dramatic diferit în Internet Explorer decât în Firefox, pictograma
•
Vinovatul poate fi un doctype lipsă sau invalid. Idiosincraziile comune care apar în paginile
web care nu au doctipuri includ dimensiuni diferite ale textului și spațiu de margine variabil
între elemente.

Există un set mic de doctipuri permise pe care le puteți utiliza. În mod implicit, paginile web nou create în
Visual Studio utilizează următorul doctype:

<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Tranzitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
Acest lucru indică faptul că pagina Web utilizează XHTML 1.0 tranzitorii. Cuvântul tranzitoriu se referă la faptul că
această versiune de XHTML este concepută pentru a fi o piatră de temelie între lumea HTML de modă veche și lumea
XHTML ultra-strictă. XHTML tranzitoriu impune toate regulile structurale ale XHTML, dar permite unele caracteristici de
formatare HTML care au fost înlocuite cu Cascading Style Sheets (CSS) și sunt considerate învechite.

Dacă nu aveți nevoie să utilizați aceste detalii, puteți trece la XHTML strict folosind acest doctype:

<! DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

Acestea sunt cele două doctipuri cele mai comune utilizate astăzi.

102
 CAPITOLUL VISUAL
4 STUDIO

XHTML VS. HTML

XHTML este o reformulare a HTML care își înăsprește regulile. Deși XHTML arată destul de similar cu HTML (și
este identic în multe cazuri), nu tolerează aceeași slăbiciune ca HTML. De exemplu, HTML tolerează informațiile
lipsă și multe greșeli minore. Din păcate, acest lucru creează o problemă cu suportul browserului web, deoarece
diferite browsere pot reacționa diferit la aceste erori minore. XHTML nu permite aceeași neglijență, astfel încât
rezultatul final este mai consistent în diferite browsere.
X-ul de la începutul XHTML înseamnă XML, deoarece XHTML este din punct de vedere tehnic o aromă de XML și
joacă după regulile sale. (XML este un standard universal pentru stocarea informațiilor într-un mod flexibil, care nu
este legat de o anumită aplicație, sistem de operare sau mediu de programare. Deși este posibil să nu știți prea
multe despre XML chiar acum, veți arunca o privire detaliată asupra acestuia în capitolul 18.)

Există o setare de configurare adânc îngropată care vă permite să schimbați modul în care
funcționează ASP.NET, astfel încât să utilizeze HTML în loc de XHTML. Dar dezvoltatorii folosesc
rareori această opțiune, cu excepția cazului în care au probleme cu documente web vechi (de
exemplu, doresc să ia pagini HTML moștenite și să le transforme în formulare web ASP.NET în cel
mai rapid mod posibil). Dacă dezvoltați un nou site web, nu există niciun motiv să nu utilizați XHTML.
(Și evitarea XHTML poate cauza probleme dacă încercați să utilizați ASP.NET AJAX toolkit, care este
descris în capitolul 25.) Dar dacă într-adevăr trebuie să știți cum să vă întoarceți în trecut, căutați în
Ajutorul Visual Studio setarea de configurare xhtmlConformance.

Notălungul acestei cărți, veți găsi multe referințe la HTML. Cu toate acestea, aceasta este
• De-a
doar o prescurtare convenabilă care include HTML și XHTML. Exemplele de pagini web pe care
le veți vedea în această carte folosesc XHTML valid.

Există încă câteva doctipuri pe care le puteți utiliza. Dacă lucrați cu un site web existent care se bazează pe
standardul HTML oarecum depășit, acesta este doctype-ul de care aveți nevoie:

<! DOCTYPE HTML PUBLIC "-//W3C//DTD HTML

4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

Și dacă doriți să utilizați standardul XHTML 1.1 ușor modificat (mai degrabă decât XHTML 1.0), aveți
nevoie de următorul doctype:

<! DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.1//EN"

"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

XHTML 1.1 este în mare parte identic cu XHTML 1.0, dar simplifică câteva detalii suplimentare și elimină
câteva detalii moștenite. Nu oferă o opțiune tranzitorie.
 CAPITOLUL VISUAL STUDIO
4

Notă alte câteva tipuri de documente pe care le puteți utiliza pentru a crea pagini de cadre,
• Există
care vă permit să împărțiți o fereastră de browser în mai multe panouri, fiecare afișând o pagină
separată. Paginile cu rame sunt descurajate în dezvoltarea web modernă, deoarece nu
funcționează bine cu diferite dimensiuni ale ferestrelor și nu sunt întotdeauna indexate corect de
motoarele de căutare. Puteți vedea o listă mai completă a doctypes-urilor permise, care include
doctype pentru o pagină de cadre, la http://www.w3.org/QA/2002/04/Web-Quality.

Amintiți-vă, controalele serverului ASP.NET vor funcționa la fel de bine cu orice doctype. Depinde de dvs.
să alegeți nivelul de conformitate a standardelor și compatibilitatea inversă pe care îl doriți în paginile dvs.
Dacă încă aveți îndoieli, cel mai bine este să începeți cu XHTML 1.0 tranzitoriu, deoarece elimină
ciudățeniile din diferite versiuni de browser fără a elimina toate caracteristicile moștenite. Dacă sunteți gata
să faceți o pauză curată cu HTML, chiar dacă înseamnă un pic mai multă durere, luați în considerare
trecerea la XHTML 1.0 strict sau XHTML 1.1 (care este întotdeauna strict).

Notă: În această carte, listele de marcare a paginilor web omit doctipul (pentru că este doar încă un detaliu care mestecă
•
pagini suplimentare). Dacă descărcați exemplul de cod, veți găsi că majoritatea paginilor
utilizează XHTML 1.1 doctype.

Elementele esențiale ale XHTML

O parte din scopul ASP.NET este de a vă permite să construiți pagini web bogate fără a vă forța să parcurgeți detaliile
plictisitoare ale XHTML (sau HTML). ASP.NET îndeplinește această promisiune în multe feluri - de exemplu, în multe
situații puteți obține rezultatul dorit folosind un singur control web elegant, mai degrabă decât să scrieți o pagină plină
de marcaj XHTML.
Cu toate acestea, ASP.NET nu vă izolează de XHTML cu totul. De fapt, o pagină web tipică ASP.NET amestecă
controalele web ASP.NET cu conținutul XHTML obișnuit. Când acea pagină este procesată de serverul web,
controalele web ASP.NET sunt convertite în marcaj XHTML (un proces cunoscut sub numele de redare) și
inserate în pagină. Rezultatul final este un document XHTML standard care este trimis înapoi la browser.

Acest design vă oferă ce este mai bun din ambele lumi - puteți amesteca marcajul XHTML obișnuit pentru părțile
paginii care nu se modifică și puteți utiliza controale web ASP.NET utile pentru părțile care trebuie să fie
interactive (cum ar fi butoane, liste, casete text etc.) sau părțile pe care trebuie să le actualizați cu informații noi
(de exemplu, un bloc de text dinamic). Acest design sugerează, de asemenea, că dezvoltatorii ASP.NET ar
trebui să aibă o înțelegere solidă a elementelor de bază XHTML înainte de a începe codificarea formularelor web.
Următoarele secțiuni oferă o scurtă prezentare generală care vă prezintă standardul XHTML (sau vă
reîmprospătează memoria, dacă ați învățat-o înainte). Dacă știți deja tot ce doriți să știți despre XHTML, nu ezitați
să treceți la secțiunea "Scrierea codului".

Notă
• Standardul XHTML complet este destul de simplu, dar este un pic dincolo de scopul acestei
cărți. Dacă doriți să aflați toate detaliile, puteți naviga la http://www.w3schools.com/xhtml pentru un
tutorial online concis.

104
 CAPITOLUL VISUAL STUDIO
4

Elemente
Cel mai important concept din standardul XHTML (și HTML) este ideea de elemente. Elementele sunt containere care
conțin biți din conținutul paginii dvs. De exemplu, dacă doriți să adăugați un paragraf de text la o pagină web, îl îndesați
într-un element de paragraf. O pagină web tipică este de fapt compusă din zeci (sau sute) de elemente. Luate împreună,
aceste elemente definesc structura paginii web. Ele sunt, de asemenea, punctul de plecare pentru formatarea paginii
web. De exemplu, titlurile arată de obicei diferit de paragrafele obișnuite, iar tabelele arată diferit de listele cu marcatori.

Limbajul XHTML definește un set mic de elemente pe care le puteți utiliza - de fapt, sunt mai puține decât
probabil vă așteptați. XHTML definește, de asemenea, sintaxa pentru utilizarea acestor elemente. Un element
tipic constă din trei piese: o etichetă de început, un anumit conținut și o etichetă de sfârșit. Iată un exemplu:
<p>Aceasta este o propoziție dintr-un paragraf.</p>
Acest exemplu utilizează elementul paragraf. Elementul începe cu eticheta <p> start, se termină cu eticheta
</p> end și conține text în interior. Etichetele sunt ușor de recunoscut, deoarece sunt întotdeauna închise
între paranteze unghiulare. Iată o combinație care adaugă un titlu la o pagină web urmat de un paragraf:

<h1>A Heading</h1> <p>Aceasta este o

propoziție dintr-un paragraf.</p>

Browserele au reguli încorporate despre cum să procesați și să afișați diferite elemente. Când un browser digeră acest
marcaj, plasează întotdeauna titlul într-un font mare, îndrăzneț și adaugă un sfârșit de linie și un spațiu suplimentar sub
acesta, înainte de a începe paragraful. Desigur, există modalități de a modifica aceste reguli de formatare folosind
standardul CSS, pe care îl veți lua în considerare în capitolul 12.
Multe elemente XHTML pot conține alte elemente. De exemplu, puteți utiliza elementul <b> din interiorul
elementului <p> pentru a aplica formatarea aldină unei porțiuni dintr-un paragraf:
<p>Aceasta este o <b>propoziție</b> într-un paragraf.</p>
Elementele <h1> și <p> conțin de obicei conținut în interior. Drept urmare, acestea sunt împărțite într-o
etichetă de început și o etichetă de sfârșit. De exemplu, un titlu începe cu <h1> și se termină cu </h1>. Cu
toate acestea, unele elemente nu au nevoie de conținut și pot fi declarate folosind o sintaxă specială de
etichetă goală care îmbină eticheta de început și de sfârșit. De exemplu, elementul <br> reprezintă un sfârșit
de linie. În loc să scrieți <br></br>, puteți folosi pur și simplu <br />, așa cum se arată aici:
<p>Aceasta este linia unu.<br
/> Aceasta este linia doi.<br
/> Aceasta este linia trei.</p>
Alte elemente care pot fi utilizate în acest mod includ <img> (pentru afișarea unei imagini), <hr> (pentru
crearea unei reguli orizontale sau a unei linii) și majoritatea controalelor ASP.NET.

Notă
• Sfârșiturile de linie sunt importante deoarece XHTML restrânge spațiile albe. Asta înseamnă că
puteți adăuga o serie de spații, file și returnări hard în conținutul elementului dvs., iar browserul va
reda pur și simplu un singur caracter spațiu. Dacă doriți cu adevărat sfârșituri de linie, trebuie să
utilizați elemente separate (de exemplu, mai multe paragrafe <p>) sau întreruperi de linie. Dacă
doriți spații suplimentare, trebuie să adăugați entitatea de caractere HTML &nbsp; în schimb
(care înseamnă spațiu non-rupere). Browserul convertește acest cod într-un singur caracter
spațiu.

105
 CAPITOLUL VISUAL STUDIO
4

Tabelul 4-1 listează unele dintre cele mai frecvent utilizate elemente XHTML. Coloana Tip face distincție
între două tipuri de XHTML - cele care conțin de obicei conținut sau alte elemente imbricate (containere) și
cele care pot fi utilizate singure cu sintaxa etichetei goale pe care tocmai ați considerat-o (independentă).
Tabelul 4-1. Elemente XHTML de bază

Etichetă Nume Tip Descriere

<b>, <i>, <u> Aldin, Container Aceste elemente sunt utilizate pentru a aplica formatarea de
cursiv, bază și pentru a face textul aldin, cursiv sau subliniat. Unii
subliniat designeri web preferă să folosească <puternic> în loc de
<b> și <accent> în loc de <i>. Deși aceste elemente au
aceeași redare standard (aldine și, respectiv, italice), ele au
mai mult sens dacă intenționați să utilizați stiluri pentru a
schimba formatarea cândva în viitor.
<p> Paragraf Container Paragraful grupează împreună un bloc de text care curge
liber. Browserul adaugă automat un pic de spațiu între
paragrafe și alte elemente (cum ar fi titlurile) sau între
paragrafele următoare.
<H1>, Rubrica Container Aceste elemente sunt titluri, care conferă textului formatare
<H2>, îndrăzneață și o dimensiune mare a fontului. Cu cât numărul
<H3>, este mai mic, cu atât textul este mai mare, deci <h1> este
<H4>, pentru cel mai mare titlu. Titlul <h5> are dimensiunea normală a
textului, iar <h6> este de fapt puțin mai mic decât textul obișnuit.
<H5>, <H6>
<IMG> Imagine De sine Elementul imagine prezintă un fișier imagine extern
stătătoare (specificat de atributul src) într-o pagină web.

<BR> Sfârșit de linie De sine Acest element adaugă un singur sfârșit de linie,
stătătoare fără spațiu suplimentar.

<ore> Linie De sine Acest element adaugă o linie orizontală (care obține lățimea
orizontală stătătoare completă a elementului care conține). Puteți utiliza linia
orizontală pentru a separa diferite regiuni de conținut.

<a> Ancoră Container Elementul ancoră împachetează o bucată de text și o

transformă într-o legătură. Setați ținta linkului utilizând
atributul href.

<ul>, <li> Listă Container Aceste elemente vă permit să creați liste cu marcatori.
neordonată, Elementul <ul> definește lista, în timp ce elementul <li>
element listă definește un element din listă (imbricați conținutul real
pentru acel element în interior).
<bere>, <li> Listă Container Aceste elemente vă permit să construiți liste numerotate.
ordonată, Elementul <ol> definește lista, în timp ce elementul <li>
element listă definește un element din listă (imbricați conținutul real
pentru acel element în interior).

106
 CAPITOLUL VISUAL STUDIO
4

Etichetă Nume Tip Descriere

<tabel>, <tr>, Masă Container Elementul <tabel> vă permite să creați un tabel cu mai
<td>, <th> multe coloane, cu mai multe rânduri. Fiecare rând este
reprezentat de un element <tr> în interiorul <tabelului>.
Fiecare celulă dintr-un rând este reprezentată de un
element <td> în interiorul unui <tr>. Plasați conținutul
real pentru celulă în elementele individuale <td> (sau, în
cazul celulelor antet care stau în partea de sus a
tabelului, puteți utiliza în schimb elemente <th>).
<div> Divizie Container Acest element este un container universal pentru alte
elemente. Este folosit pentru a separa diferite regiuni de
pe pagină, astfel încât să le puteți formata sau poziționa
separat. De exemplu, puteți utiliza un <div> pentru a crea
o casetă umbrită în jurul unui grup de elemente.
<span> Span Container Acest element este un container universal pentru biți de
conținut text din interiorul altor elemente (cum ar fi titluri sau
paragrafe). Este cel mai frecvent utilizat pentru a formata
acei biți de text. De exemplu, puteți utiliza un <span> pentru
a schimba culoarea câtorva cuvinte dintr-o propoziție.

<formă> Formular Container Acest element este utilizat pentru a ține toate controalele de
pe o pagină web. Controalele sunt elemente HTML care pot
trimite informații înapoi la serverul web atunci când pagina
este trimisă. De exemplu, casetele text își trimit textul,
casetele listă trimit elementul selectat curent din listă și așa
mai departe.

Atribute
Fiecare document XHTML fuzioneaza impreuna doua tipuri de informatii: continutul documentului si informatii despre
modul in care acel continut ar trebui sa fie prezentat. Controlați prezentarea conținutului dvs. în doar trei moduri: utilizând
elementele potrivite, aranjând aceste elemente pentru a obține structura corectă și adăugând atribute elementelor dvs.

Atributele sunt informații individuale pe care le atașați unui element, în interiorul etichetei de început.
Atributele au multe utilizări - de exemplu, vă permit să atașați în mod explicit un stil unui element, astfel încât
acesta să obțină formatarea corectă. Unele elemente necesită atribute. Cel mai evident exemplu este
elementul <img>, care vă permite să extrageți conținutul dintr-un fișier imagine și să îl plasați în pagina dvs.
web. Eticheta <img> necesită două informații: URL-ul imaginii (sursa) și textul alternativ care descrie imaginea
(care este utilizat în scopuri de accesibilitate, ca și în cazul software-ului de citire a ecranului). Aceste două
informații sunt specificate folosind două atribute, numite src și alt:
<img src="happy.gif" alt="Fata fericita" />
Elementul ancoră <a> este un exemplu de element care utilizează atribute și preia conținut. Conținutul din
interiorul elementului <a> este textul albastru, subliniat al hyperlinkului. Atributul href definește destinația
la care va naviga browserul atunci când se face clic pe link.

107
 CAPITOLUL VISUAL STUDIO
4

<p> Faceți clic pe <a ="http://www.prosetech.com">aici</a> pentru a vizita site-ul meu web.

HREF
</p>

Veți utiliza pe scară largă atributele cu etichetele de control ASP.NET. Cu ASP.NET controale, fiecare
atribut se mapează la o proprietate a clasei de control.

Formatare
Împreună cu elementul <b> (sau <puternic>) pentru bold, XHTML suportă, de asemenea, elementul <i> (sau
<accent>) pentru italice. Cu toate acestea, aceasta este cam în ceea ce privește formatarea sa.
Elementele XHTML sunt destinate să indice structura unui document, nu formatarea acestuia. Deși puteți
ajusta culorile, fonturile și unele caracteristici de formatare utilizând elemente XHTML, o abordare mai bună
este definirea formatării utilizând o foaie de stil CSS. De exemplu, o foaie de stil poate spune browserului
să utilizeze formatare specifică pentru fiecare element <h1> dintr-o pagină. Puteți chiar să aplicați stilurile
dintr-o foaie de stil tuturor paginilor de pe site-ul dvs.

• Sfat: În exemplele descărcabile, veți descoperi că multe dintre paginile web utilizează o foaie
de stil numită Styles.css. Această foaie de stiluri aplică fontul Verdana tuturor elementelor paginii
web.

Într-o pagină web ASP.NET, există două moduri în care puteți utiliza CSS. Îl puteți utiliza direct pentru a
formata elemente. Capitolul 12 prezintă elementele de bază ale acestei abordări. Sau puteți configura
proprietățile controalelor de ASP.NET pe care le utilizați, iar acestea vor genera automat stilurile de care
au nevoie, după cum veți vedea pe parcursul acestei cărți.

O pagină web completă

Acum știți suficient pentru a pune împreună o pagină XHTML completă.
Fiecare document XHTML începe cu această structură de bază (imediat după doctype):

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server"> <title>Untitled Page</title>
</head> <body>

</corp> </html>

Când creați un formular web nou în Visual Studio, aceasta este structura cu care începeți. Iată ce obțineți:

• Documentele XHTML încep cu eticheta <html> și se termină cu eticheta </html>.

Acest element <html> conține conținutul complet al paginii web.
• În interiorul elementului <html>, pagina web este împărțită în două porțiuni. Prima
porțiune este elementul <cap>, care stochează unele informații despre pagina
web. Veți utiliza acest lucru pentru a stoca titlul paginii dvs. web, care va apărea în

108
 CAPITOLUL VISUAL
4 STUDIO

bara de titlu din browserul web. (Puteți adăuga, de asemenea, alte detalii aici, cum ar fi
cuvintele cheie de căutare, deși acestea sunt în mare parte ignorate de browserele web în
aceste zile.) Când generați o pagină web în Visual Studio, secțiunea <head> are un atribut
runat = "server". Acest lucru vă oferă posibilitatea de a-l manipula în codul dvs. (un subiect
pe care îl veți explora în capitolul următor).
• A doua porțiune este elementul <body>, care conține conținutul real al
paginii care apare în fereastra browserului web.
Într-o pagină web ASP.NET, există cel puțin încă un element. În interiorul elementului <corp> este un element <formă>.
Elementul <formular> este necesar deoarece definește o porțiune a paginii care poate trimite informații înapoi la
serverul web. Acest lucru devine important atunci când începeți să adăugați casete text, liste și alte controale. Atâta
timp cât sunt într-un formular, informații precum textul curent din caseta text și selecția curentă din listă vor fi trimise
serverului web utilizând un proces cunoscut sub numele de postback. Din fericire, nu trebuie să vă faceți griji cu privire
la acest detaliu încă - trebuie doar să plasați tot conținutul paginii dvs. web în elementul <formular>.

De cele mai multe ori, atunci când lucrați cu o pagină, vă veți concentra pe marcajul din interiorul
elementului <formular>, care conține cea mai mare parte a conținutului paginii. Când creați o pagină web
nouă în Visual Studio, mai există un detaliu - elementul <div> din interiorul elementului <formular>:
<html xmlns="http://www.w3.org/1999/xhtml"> <head runat="server"> <title>Untitled Page</title> </head>
<body>

<form ID="form1" runat="server"> <div> </div> </form> </body> </html>

Strict vorbind, elementul <div> este opțional - este doar un container. Vă puteți gândi la ea ca la o cutie
invizibilă care nu are aspect sau formatare încorporată. Cu toate acestea, este util să utilizați o etichetă
<div> pentru a grupa porțiunile din pagină pe care doriți să le formatați într-un mod similar (de exemplu, cu
același font, culoare de fundal sau bordură). În acest fel, puteți aplica setări de stil etichetei <div> iar
acestea vor cădea în cascadă în fiecare etichetă pe care o conține. De asemenea, puteți crea o casetă
reală pe pagina dvs., oferind <div> o bordură. Veți afla mai multe despre formatare și elementul <div> din
capitolul 12.

• Notă Elementul <div> este, de asemenea, util, deoarece puteți plasa text direct în interiorul
acestuia, fără a avea nevoie de un element container (cum ar fi un paragraf). Pe de altă parte,
adăugarea de text direct în interiorul elementului <formular> încalcă regulile XHTML.

Acum sunteți gata să introduceți restul conținutului în eticheta <div>. Dacă adăugați un control Etichetă,
Casetă text și Buton, veți obține același marcaj pe care l-ați creat utilizând proiectantul mai devreme în
acest capitol, dar acum veți înțelege bazele marcajului.
 CAPITOLUL VISUAL STUDIO
4

Scrierea codului
Multe dintre cele mai binevenite îmbunătățiri ale Visual Studio apar atunci când începeți să scrieți codul
care acceptă interfața cu utilizatorul. Pentru a începe codificarea, trebuie să comutați la vizualizarea cod
din spate. Pentru a comuta înainte și înapoi, puteți utiliza două butoane Vizualizare cod sau Proiectant
vizualizare, care apar chiar deasupra ferestrei Explorator de soluții. O altă abordare care funcționează la
fel de bine este să faceți dublu clic fie pe pagina .aspx din Exploratorul de soluții (pentru a ajunge la
proiectant), fie pe pagina .aspx.cs (pentru a accesa vizualizarea codului). "Codul" în cauză este codul C#,
nu marcajul HTML din fișierul .aspx.
Clasa din spatele codului
Când comutați la vizualizarea cod, veți vedea clasa de pagini pentru pagina web. De exemplu, dacă ați creat
o pagină web numită SimplePage.aspx, veți vedea o clasă în spatele codului care arată astfel:

folosind Sistem; folosind Sistem;

folosind System.Collections.Generic;
folosind System.Linq; folosind
System.Web; folosind
System.Web.UI; folosind
System.Web.UI.WebControls;

public clasa parțială SimplePage: System.Web.UI.Page { protejat

void Page_Load(expeditor obiect, EventArgs e) {

}}

Chiar înainte de clasa de pagini, Visual Studio importă un număr de spații de nume .NET de bază. Aceste
spații de nume vă oferă acces ușor la multe clase de ASP.NET utilizate în mod obișnuit.
În cadrul clasei de pagini puteți plasa metode, care vor răspunde la evenimentele de control. De exemplu,
puteți adăuga o metodă cu cod care reacționează atunci când utilizatorul face clic pe un buton.
Următoarea secțiune explică modul în care puteți crea o rutină de tratare a evenimentelor.

Adăugarea rutinelor de tratare a evenimentelor

Cea mai mare parte a codului dintr-o pagină web ASP.NET este plasată în rutinele de tratare a evenimentelor
care reacționează la evenimentele de control web. Folosind Visual Studio, aveți trei modalități simple de a adăuga
o rutină de tratare a evenimentelor la codul dvs.:
Tastați-l manual: În acest caz, adăugați subrutina direct la clasa de pagini din fișierul cod C#. Trebuie
să specificați parametrii corespunzători.
Faceți dublu clic pe un control în vizualizarea proiect: În acest caz, Visual Studio va crea o rutină de
tratare a evenimentelor pentru evenimentul implicit al acelui control, dacă acesta nu există deja. De
exemplu, dacă faceți dublu clic pe un control Buton, acesta va crea o rutină de tratare a evenimentelor
pentru evenimentul Button.Click. Dacă faceți dublu clic pe un control TextBox, veți obține o rutină de
tratare a evenimentelor pentru evenimentul TextBox.TextChanged. Dacă rutina de tratare a
evenimentelor există deja, Visual Studio vă duce pur și simplu la locul relevant din codul dvs.

110
 CAPITOLUL VISUAL STUDIO
4

Alegeți evenimentul din fereastra Proprietăți: Doar selectați controlul și faceți clic pe fulgerul din
fereastra Proprietăți. Veți vedea o listă cu toate evenimentele furnizate de acel control. Faceți dublu clic
lângă evenimentul pe care doriți să îl gestionați și Visual Studio va genera automat rutina de tratare a
evenimentelor în clasa de pagini. Alternativ, dacă ați creat deja metoda de tratare a evenimentelor,
selectați evenimentul în fereastra Proprietăți și faceți clic pe săgeata verticală din dreapta. Veți vedea o
listă care include toate metodele din clasa dvs. care se potrivesc cu semnătura necesară acestui
eveniment. Apoi puteți alege o metodă din listă pentru a o conecta. Figura 4-13 prezintă un exemplu în
care evenimentul Button.Click este conectat la metoda Button1_Click din clasa de pagini.

Sfat utilizați ultima abordare, este posibil să dați peste o ciudățenie Visual Studio. Uneori, în
• Dacă
timp ce editați în vizualizarea sursă, fereastra Proprietăți nu va afișa pictograma fulger pentru
controlul curent. Pentru a remedia această problemă, comutați în vizualizarea proiect și selectați
controlul acolo.

Figura 4-13. Crearea sau atașarea unei rutine de tratare a evenimentelor

Indiferent de abordarea pe care o utilizați, rutina de tratare a evenimentelor arată (și funcționează) la
fel. De exemplu, când faceți dublu clic pe un control buton, Visual Studio creează o rutină de tratare a
evenimentelor ca aceasta:
protejat void Button1_Click(expeditor obiect, EventArgs e) { // Codul
dvs. pentru reacția la clic pe buton merge aici. }

Când utilizați Visual Studio pentru a atașa sau a crea o rutină de tratare a evenimentelor, ajustează eticheta
de control astfel încât să fie legată la evenimentul corespunzător:

111
 CAPITOLUL VISUAL STUDIO
4

<asp:Button ID="Button1" runat="server" text="Button" OnClick ="Button1_Click" />

În cadrul metodei de tratare a evenimentelor, puteți interacționa cu oricare dintre obiectele de control de pe
pagina dvs. web utilizând ID-urile acestora. De exemplu, dacă ați creat un control TextBox numit TextBox1,
puteți seta textul utilizând următoarea linie de cod:
protejat void Button1_Click(expeditor obiect, EventArgs e) {

TextBox1.Text = "Iată câteva exemple de text.";

}

Acesta este un handler simplu de evenimente care reacționează atunci când se face clic pe Button1 și actualizează textul din
TextBox1.

Notă S-ar putea să vă întrebați de ce fișierul cod include rutinele de tratare a evenimentelor, dar nu declară de fapt
• controalele pe care le utilizați (cum ar fi obiectele Button1 și TextBox1 din exemplul anterior).
Motivul este că ASP.NET generează automat declarațiile pentru aceste controale. Nu veți vedea
niciodată aceste declarații, dar puteți presupune că fac parte din clasa dvs. Acesta este și motivul
pentru care fiecare clasă de pagini pe care o creați este definită cu cuvântul cheie parțial. Acest
lucru ASP.NET permite să îmbinați codul cu porțiunea pe care o generează automat. Rezultatul
final este că puteți accesa cu ușurință toate controalele de pe pagina dvs. după nume, dar nu
trebuie să vă deranjați cu cod suplimentar pentru a crea și inițializa aceste obiecte.

Veți afla mult mai multe despre modul în care funcționează modelul de formular web ASP.NET în
următoarele două capitole. Dar pentru restul capitolului, este timpul să luăm o mică pauză și să luăm în
considerare două dintre marile facilități de codare ale Visual Studio: conturarea și IntelliSense.

Schiţare
Schițarea permite Visual Studio să "restrângă" o metodă, o clasă, o structură, un spațiu de nume sau o
regiune la o singură linie. Vă permite să vedeți codul care vă interesează în timp ce ascundeți codul
neimportant. Pentru a restrânge o porțiune de cod, faceți clic pe simbolul minus (–) de lângă prima linie.
Pentru ao extinde, faceți clic din nou pe casetă, care va avea acum un simbol plus (+) (a se vedea figura
4-14).

112
 CAPITOLUL VISUAL STUDIO
4

Figura 4-14. Cod de colaps

Puteți ascunde fiecare metodă simultan făcând clic dreapta oriunde în fereastra de cod și alegând Restrângere la definiții.

IntelliSense
Visual Studio încearcă din greu să vă facă viața mai ușoară cu o serie de economii automate de timp. Cel
mai puternic dintre acestea este IntelliSense - un grup de caracteristici care vă solicită sugestii valoroase
de cod (și detectează greșeli) pe măsură ce tastați.

Lista membrilor
Visual Studio vă ajută să interacționați cu controale și clase. Când tastați un nume de clasă sau obiect, apare
o listă de proprietăți și metode disponibile care se potrivesc cu ceea ce ați tastat până acum (consultați
Figura 4-15). Utilizează un truc similar pentru a furniza o listă de tipuri de date atunci când definiți o variabilă
sau pentru a furniza o listă de valori valide atunci când atribuiți o valoare unei enumerări.

113
 CAPITOLUL VISUAL STUDIO
4

Figura 4-15. IntelliSense la locul de muncă

Sfat
• Ați uitat numele controalelor din pagina Web? Puteți obține IntelliSense pentru a vă ajuta. Doar
tastați acest cuvânt cheie urmat de un punct (cunoscut și sub numele de operator de puncte).
Visual Studio va afișa o listă cu toate metodele și proprietățile clasei de formular curente, inclusiv
variabilele de control.

Visual Studio oferă, de asemenea, o listă de parametri și tipurile lor de date atunci când apelați o metodă
sau invocați un constructor. Aceste informații sunt prezentate într-un sfat ecran sub cod și apar pe măsură ce
tastați. Deoarece biblioteca de clase .NET utilizează metode de supraîncărcare foarte mult, aceste metode
pot avea mai multe versiuni. Când o fac, Visual Studio indică numărul de versiuni și vă permite să vedeți
definițiile metodelor pentru fiecare făcând clic pe săgețile mici în sus și în jos din sfatul ecran. De fiecare dată
când faceți clic pe săgeată, sfatul ecran afișează o versiune diferită a metodei supraîncărcate (consultați
Figura 4-16).

114
 CAPITOLUL VISUAL STUDIO
4

Figura 4-16. IntelliSense cu metode supraîncărcate

Eroare la subliniere
Una dintre cele mai utile caracteristici ale editorului de cod este sublinierea erorilor. Visual Studio este capabil
să detecteze o varietate de condiții de eroare, cum ar fi variabile, proprietăți sau metode nedefinite; conversii
de tip de date nevalide; și elemente de cod lipsă. În loc să vă oprească pentru a vă avertiza că există o
problemă, editorul Visual Studio subliniază codul ofensator. Puteți trece cu mouse-ul peste o eroare subliniată
pentru a vedea o scurtă descriere a problemei (consultați Figura 4-17).

Figura 4-17. Evidențierea erorilor la momentul proiectării

115
 CAPITOLUL VISUAL STUDIO
4

Visual Studio nu va semnaliza neapărat erorile imediat. Dar când încercați să rulați aplicația (sau doar să o compilați),
Visual Studio va scana rapid codul, marcând toate erorile pe care le găsește. În cazul în care codul conține cel puțin o
eroare, Visual Studio vă va întreba dacă ar trebui să continue. În acest moment, veți decide aproape întotdeauna să
anulați operațiunea și să remediați problemele descoperite de Visual Studio. (Dacă alegeți să continuați, veți ajunge să
utilizați ultima versiune compilată a aplicației, deoarece Visual Studio nu poate construi o aplicație care are erori.)

Ori de câte ori încercați să construiți o aplicație care are erori, Visual Studio va afișa fereastra Listă de
erori cu o listă cu toate problemele detectate, așa cum se arată în Figura 4-18. Apoi puteți sări rapid la o
problemă făcând dublu clic pe ea în listă.

Figura 4-18. Fereastra Listă de erori

Este posibil să descoperiți că, pe măsură ce remediați erorile și reconstruiți aplicația, descoperiți mai multe probleme.
Acest lucru se datorează faptului că Visual Studio nu verifică toate tipurile de erori simultan. Când încercați să compilați
aplicația, Visual Studio scanează pentru probleme de bază, cum ar fi nume de clase nerecunoscute. Dacă există aceste
probleme, ele pot masca cu ușurință alte erori. Pe de altă parte, dacă codul trece acest nivel de inspecție de bază,
Visual Studio verifică probleme mai subtile, cum ar fi încercarea de a utiliza o variabilă neatribuită.

De asemenea, puteți configura nivelul de verificare a erorilor pe care Visual Studio îl efectuează pentru marcare în
fișierele .aspx. De obicei, veți dori să setați nivelul de validare pentru a se potrivi cu tipul de document pe care îl
utilizați. Din păcate, Visual Studio nu face acest pas automat. În schimb, depinde de dvs. să alegeți nivelul de
validare dorit din lista derulantă din bara de instrumente Editare sursă HTML. (Dacă bara de instrumente Editare
sursă HTML nu este afișată momentan, faceți clic dreapta pe banda barei de instrumente și selectați Editare sursă
HTML.) Cele mai comune opțiuni de validare sunt HTML 4.01, XHTML 1.0 Transition și XHTML 1.1. De exemplu,
dacă alegeți XHTML 1.0 Transitional sau XHTML 1.1, veți primi un avertisment în Lista de erori dacă pagina web
include sintaxă care nu este legală în XHTML, cum ar fi scrierea incorectă cu majuscule, un atribut de formatare
învechit sau un element care nu este închis corect. Veți putea în continuare să rulați pagina web, dar veți ști că
pagina dvs. nu este complet compatibilă cu standardul XHTML.

Importul automat al spațiilor de nume

Uneori, veți întâmpina o eroare, deoarece nu ați importat un spațiu de nume de care aveți nevoie. De
exemplu, imaginați-vă că tastați o linie de cod ca aceasta:
FileStream fs = nou FileStream ("newfile.txt", FileMode.Create);

116
 CAPITOLUL VISUAL STUDIO
4

Această linie creează o instanță a clasei FileStream, care se află în spațiul de nume System.IO. Cu toate
acestea, dacă nu ați importat spațiul de nume System.IO, veți întâmpina o eroare de compilare. Din păcate,
eroarea indică pur și simplu că nu există nicio clasă cunoscută numită FileStream - nu indică dacă problema este
o ortografie greșită sau un import lipsă și nu vă spune ce spațiu de nume are clasa de care aveți nevoie.
Visual Studio oferă un instrument neprețuit pentru a vă ajuta în această situație. Când mutați cursorul text la numele
clasei nerecunoscute (FileStream în acest exemplu), o pictogramă casetă mică apare dedesubt. Dacă treceți cu mouse-ul
peste acea locație, apare o pictogramă de pagină. Faceți clic pe pictograma paginii și apare o listă verticală cu opțiuni de
corectare automată (consultați Figura 4-19). Folosind aceste opțiuni, puteți converti linia pentru a utiliza numele clasei
complet calificate sau puteți adăuga importul spațiului de nume necesar în partea de sus a fișierului de cod, care este, în
general, cea mai curată opțiune (mai ales dacă utilizați clase din acel spațiu de nume de mai multe ori în aceeași pagină).

Singurul caz în care această caracteristică de corectare automată nu va funcționa este dacă Visual Studio
nu poate găsi clasa lipsă. Acest lucru se poate întâmpla dacă clasa există într-o altă adunare și nu ați
adăugat încă o referință la acea adunare.

Figura 4-19. Importul unui spațiu de nume lipsă

Formatarea și colorarea codului

Visual Studio oferă, de asemenea, unele facilități cosmetice. Vă colorează automat codul, făcând comentariile verzi, cuvintele cheie albastre și
codul normal negru. Rezultatul este un cod mult mai lizibil. Puteți chiar să configurați culorile utilizate de Visual Studio selectând Instrumente

→ Opțiuni și apoi alegeți Mediul

￫ secțiunea Fonturi și culori.
În plus, Visual Studio este configurat implicit pentru formatarea automată a codului. Aceasta înseamnă că puteți

117
 CAPITOLUL VISUAL STUDIO
4

introduce liniile de cod în mod liber, fără să vă faceți griji cu privire la file și poziționare. Visual Studio aplică automat
indentarea "corectă". Din fericire, dacă aveți o preferință diferită (de exemplu, doriți cinci spații în loc de patru spații
de indentare sau doriți să utilizați file în loc de spații), puteți configura acest comportament. Doar selectați
Instrumente Opțiuni și găsiți grupul de setări Text Editor C#.

Depanare Visual Studio

După ce ați creat o aplicație, o puteți compila și rula alegând Debug Start Debugging din meniu, făcând
clic pe butonul Start Debugging de pe bara de instrumente (care arată ca un buton de redare în stil DVD)
sau apăsând F5. Visual Studio lansează browserul web implicit și solicită pagina selectată în prezent în
Exploratorul de soluții. Acesta este un truc util - dacă vă aflați în mijlocul SalesPage1.aspx de codificare,
veți vedea SalesPage1.aspx apar în browser, nu în pagina de pornire Default.aspx.
Prima dată când lansați o aplicație web, Visual Studio vă va întreba dacă doriți să configurați aplicația web
pentru a permite depanarea prin ajustarea fișierului său de configurare. (Figura 4-20 arată mesajul pe care
îl veți vedea.) Alegeți "Modificați fișierul Web.config pentru a activa depanarea" și faceți clic pe OK.

Figura 4-20. Activarea depanării

The Visual Studio Web Server

Când executați o aplicație web, Visual Studio pornește serverul web integrat. În culise, ASP.NET compilează codul
pentru aplicația dvs. web, rulează pagina dvs. web și apoi returnează codul HTML final în browser. Prima dată când rulați
o pagină web, veți vedea o pictogramă nouă care apare în bara de sistem din colțul din dreapta jos al barei de activități.
Această pictogramă este serverul web de testare Visual Studio, care rulează în fundal găzduind site-ul dvs. Serverul de
testare se execută numai în timp ce se execută Visual Studio și acceptă numai solicitări de la computer (astfel încât alți
utilizatori să nu se poată conecta la acesta printr-o rețea).
Când rulați o pagină web, veți observa că adresa URL din browser include un număr de port. De exemplu,
dacă executați o aplicație web într-un folder numit OnlineBank, este posibil să vedeți o adresă URL ca
http://localhost:4235/OnlineBank/Default.aspx. Acest URL indică faptul că serverul web rulează pe
computer (localhost), astfel încât solicitările sale nu sunt trimise prin Internet. De asemenea, indică faptul că
toate cererile sunt transmise la numărul portului 4235. În acest fel, solicitările nu vor intra în conflict cu alte
aplicații care ar putea rula pe computer și asculta solicitările. De fiecare dată când Visual Studio pornește
serverul web integrat, alege aleatoriu un port disponibil.

118
 CAPITOLUL VISUAL
4 STUDIO

Serverul web încorporat în Visual Studio vă permite, de asemenea, să recuperați o listă a tuturor fișierelor de pe
site-ul dvs. Aceasta înseamnă că, dacă creați o aplicație web numită SampleSite, o puteți solicita în formularul
http://localhost:port/SampleSite (omițând numele paginii) pentru a vedea o listă cu toate fișierele din folderul
aplicației web (a se vedea Figura 4-21). Apoi, trebuie doar să faceți clic pe pagina pe care doriți să o testați.

Figura 4-21. Alegerea dintr-o listă de pagini

Acest truc nu va funcționa dacă aveți o pagină Default.aspx. Dacă faceți acest lucru, toate solicitările care
nu indică pagina dorită sunt redirecționate automat către această pagină.

Depanare într-un singur pas

Depanarea într-un singur pas vă permite să vă testați ipotezele despre modul în care funcționează codul dvs. și să
vedeți ce se întâmplă cu adevărat sub capota aplicației dvs. Este incredibil de ușor de utilizat. Doar urmați acești pași:
1. Găsiți o locație în codul dvs. unde doriți să întrerupeți execuția. (Puteți utiliza
orice linie executabilă de cod, dar nu o declarație variabilă, un comentariu sau o
linie goală.) Faceți clic în marginea de lângă linia de cod (sau apăsați F9) și va
apărea un punct de întrerupere roșu. Figura 4-22 prezintă o pagină extrem de
simplă, care citește conținutul numeric dintr-un control TextBox, îl înmulțește cu
doi și îl afișează într-un control Etichetă. (Dacă doriți să exersați singur depanarea
acestei pagini, o puteți obține cu exemplul de cod pentru acest capitol.)
 CAPITOLUL VISUAL STUDIO
4

Figura 4-22. Setarea unui punct critic

2. Acum porniți programul așa cum ați face de obicei (apăsând tasta F5 sau utilizând
butonul Start de pe bara de instrumente). Când programul ajunge la punctul de
întrerupere, execuția se va întrerupe și veți fi comutat la fereastra de cod Visual
Studio. Declarația punctului de întrerupere nu va fi încă executată.
3. În acest moment, aveți mai multe opțiuni. Puteți executa linia curentă apăsând F11.
Următoarea linie din codul dvs. va fi evidențiată cu o săgeată galbenă, indicând faptul
că aceasta este următoarea linie care va fi executată. Puteți continua astfel prin
programul dvs., rulând o linie la un moment dat apăsând F11 și urmând calea de
execuție a codului.
4. Ori de câte ori codul este în modul pauză, puteți trece cu mouse-ul peste
variabile pentru a vedea conținutul lor curent (a se vedea figura 4-23). Acest lucru
vă permite să verificați dacă variabilele conțin valorile pe care le așteptați.

120
 CAPITOLUL VISUAL STUDIO
4

Figura 4-23. Vizualizarea conținutului variabil în modul pauză

5. De asemenea, puteți utiliza oricare dintre comenzile enumerate în tabelul

4-2 în modul pauză. Aceste comenzi sunt disponibile din meniul
contextual făcând clic dreapta pe fereastra de cod sau utilizând tasta
rapidă asociată.

121
 CAPITOLUL VISUAL STUDIO
4

Tabelul 4-2. Comenzi disponibile în modul pauză

Comandă (tastă rapidă) Descriere

Intră în (F11) Execută linia evidențiată curent, apoi se întrerupe. Dacă în prezent
Linia evidențiată apelează o metodă, execuția se va întrerupe la primul executabil
linie în interiorul metodei (motiv pentru care această caracteristică se numește pășire ).

Pas peste (F10) La fel ca Step Into, cu excepția faptului că rulează metode ca și cum ar fi o singură linie.
Dacă selectați Pas înainte în timp ce este evidențiat un apel de metodă, întreaga metodă
vor fi executate. Execuția se va întrerupe la următoarea declarație executabilă din
metoda curentă.

Ieșire (Shift+F11) Execută tot codul în procedura curentă și apoi se oprește la

afirmație care urmează imediat celui care a numit această metodă sau
funcționa. Cu alte cuvinte, acest lucru vă permite să ieșiți "afară" din curent
procedură într-un salt mare.

Continuare (F5) Reia programul și continuă să îl ruleze normal, fără întrerupere până la
Se ajunge la un alt punct critic.

Alergare la cursor Vă permite să rulați tot codul până la o anumită linie (unde cursorul
este poziționat în prezent). Puteți utiliza această tehnică pentru a sări peste un consumator de timp
Buclă.

Setați următoarea declarație
Vă permite să modificați calea de execuție a programului în timpul depanării.
Această comandă determină programul să marcheze linia curentă (unde
cursorul este poziționat) ca linie curentă pentru execuție. Când reluați
execuție, această linie va fi executată, iar programul va continua de la aceasta
punct. Deși această tehnică este convenabilă pentru a sări peste bucle mari și
simulând anumite condiții, este ușor să provocați confuzie și erori de rulare
folosindu-l nesăbuit.

Afișați următoarea declarație Vă aduce la linia de cod unde este oprit în prezent Visual Studio. (Aceasta este
linia de cod care va fi executată în continuare când continuați.) Această linie este
marcat cu o săgeată galbenă. Comanda Afișare instrucțiune următoare este utilă dacă:
Vă pierdeți locul în timpul editării.

Puteți comuta programul în modul pauză în orice moment, făcând clic pe butonul Pauză din bara de
instrumente sau selectând Debug Break All. Cu toate acestea, este posibil ca acest lucru să nu vă
oprească codul acolo unde vă așteptați, așa că va trebui să scotociți în jur pentru a vă orienta.

• Sfat Deoarece abia începeți cu ASP.NET, nu veți avea mult cod de depanat. Cu toate acestea,
asigurați-vă că reveniți la această secțiune pe măsură ce încercați exemple mai detaliate în
capitolele următoare. Instrumentele de depanare ale Visual Studio sunt o modalitate neprețuită de
a obține o privire de aproape asupra modului în care funcționează codul.

122
 CAPITOLUL VISUAL STUDIO
4

Când depanați un site web mare, este posibil să plasați puncte de întrerupere în diferite locuri din cod și
în mai multe pagini web. Pentru a arunca o privire asupra tuturor punctelor de întrerupere din aplicația
web, alegeți Debug Windows Puncte de întrerupere. Veți vedea o listă cu toate punctele de
întrerupere, așa cum se arată în Figura 4-24).

Figura 4-24. Fereastra Puncte de întrerupere

Puteți sări la locația din cod unde este plasat un punct de întrerupere făcând dublu clic pe acesta în listă. De
asemenea, puteți să eliminați un punct de întrerupere (selectați-l și apăsați Delete) sau să dezactivați
temporar un punct de întrerupere (eliminând bifa de lângă acesta). Acest lucru vă permite să păstrați un
punct de întrerupere pentru a-l utiliza în testarea ulterioară, fără a-l lăsa activ.

PUNCTE DE ÎNTRERUPERE AVANSATE

Visual Studio vă permite să particularizați punctele de întrerupere, astfel încât acestea să apară numai dacă anumite
condiții sunt adevărate. Pentru a particulariza un punct de întrerupere, faceți clic dreapta pe acesta în fereastra Puncte de
întrerupere. Va apărea un meniu pop-up cu mai multe opțiuni pentru condiționarea punctului de întrerupere:

• Faceți clic pe Locație pentru a vedea exact codul fișierului și linia în care este poziționat acest punct de întrerupere.
• Faceți clic pe Condiție pentru a seta o expresie. Puteți alege să întrerupeți atunci când această
expresie este adevărată sau când s-a modificat de la ultima atingere a punctului de întrerupere.

• Faceți clic pe Număr de accesări pentru a crea un punct de întrerupere care se întrerupe
numai după ce un punct de întrerupere a fost atins de un anumit număr de ori (de exemplu,
cel puțin 20) sau un anumit multiplu de ori (de exemplu, la fiecare a cincea oară).

• Faceți clic pe Filtru pentru a restricționa punctul de întrerupere la anumite procese

sau fire. (Această tehnică este rareori utilă în codul ASP.NET de pagină web.)
• Faceți clic pe Când apăsați pentru a alege o altă acțiune pe care Visual Studio ar trebui să o
efectueze atunci când se atinge punctul de întrerupere, cum ar fi rularea unei macrocomenzi
sau imprimarea unui mesaj de depanare. Dacă alegeți să efectuați una dintre aceste acțiuni,
puteți specifica, de asemenea, dacă punctul de întrerupere ar trebui să forțeze Visual Studio în
modul de întrerupere sau dacă codul ar trebui să continue executarea.

Punctele de întrerupere sunt salvate automat cu fișierele soluției Visual Studio, deși nu
sunt utilizate atunci când compilați aplicația în modul de lansare.

123
 CAPITOLUL VISUAL STUDIO
4

Ceasuri variabile
În unele cazuri, poate doriți să urmăriți starea unei variabile fără a comuta în mod repetat în modul pauză.
În acest caz, este mai util să utilizați ferestrele Autos, Locals și Watch, care vă permit să urmăriți variabilele
dintr-o întreagă aplicație. Tabelul 4-3 descrie aceste ferestre.
Tabelul 4-3. Ferestre de supraveghere variabile

Fereastră Descriere

Masini Afișează automat variabilele pe care Visual Studio le determină ca fiind importante pentru
Declarația actuală a codului. De exemplu, aceasta poate include variabile care sunt accesate sau
schimbat în linia anterioară.

Localnici Afișează automat toate variabilele care sunt în domeniul de aplicare în metoda curentă. Aceasta oferă
Un rezumat rapid al variabilelor importante.

Ceas Afișează variabilele pe care le-ați adăugat. Ceasurile sunt salvate cu soluția dvs., astfel încât să puteți
Continuați să urmăriți o variabilă mai târziu. Pentru a adăuga un ceas, dă clic dreapta pe o variabilă din cod în timp ce
în modul pauză și selectează Adaugă un ceas. Alternativ, faceți dublu clic pe ultimul rând din Watch
și introduceți numele variabilei.

Fiecare rând din ferestrele Auto, Localnici și Ceas oferă informații despre tipul sau clasa variabilei și valoarea
sa curentă. Dacă variabila deține o instanță a obiectului, puteți extinde variabila și îi puteți vedea membrii și
proprietățile. De exemplu, în fereastra Localnici veți vedea variabila aceasta (a se vedea Figura 4-25), care
este o referință la obiectul curent în interiorul căruia se execută codul dvs. (în acest caz, pagina web). Dacă
faceți clic pe semnul plus (+) de lângă cuvântul acesta, va apărea o listă completă care descrie multe
proprietăți ale paginii (și unele valori de sistem).

124
 CAPITOLUL VISUAL STUDIO
4

Figura 4-25. Vizualizarea obiectului paginii curente în fereastra Localnici

Dacă vă lipsește una dintre ferestrele Watch, o puteți afișa manual selectând-o din submeniul Debug
Windows.

• Sfat Ferestrele Autos, Locals și Watch vă permit să modificați variabile simple în timp ce
programul este în modul pauză. Doar faceți dublu clic pe valoarea curentă din coloana Valoare și
tastați o valoare nouă. Acest lucru vă permite să simulați scenarii care sunt dificil sau
consumatoare de timp pentru a le recrea manual și vă permite să testați condiții de eroare
specifice.

Ultimul cuvânt
În acest capitol, ați aruncat o privire rapidă la Visual Studio. În primul rând, ați văzut cum să creați o nouă
aplicație web folosind modelul de site web curat fără proiect. Apoi, ați luat în considerare modul de
proiectare a paginilor web de bază, completate cu controale și cod. În cele din urmă, ați văzut cum să
utilizați setul bogat de funcții de depanare al Visual Studio pentru a intra în creierul codului paginii dvs.
web și pentru a urmări problemele evazive. În capitolul următor, veți începe să construiți aplicații web
simple cu Visual Studio și veți obține prima privire completă asupra modelului ASP.NET de pagini web.

125
CAPITOLUL5

•■■

Noțiuni fundamentale despre formularul web

În acest capitol, veți afla câteva dintre subiectele de bază pe care fiecare dezvoltator ASP.NET trebuie să le stăpânească.
Veți începe prin a arunca o privire mai atentă asupra modelului de aplicație ASP.NET și luând în considerare ce fișiere și
foldere aparțin unei aplicații web. Apoi, veți arunca o privire mai atentă asupra controalelor serverului, blocul de bază al
oricărui formular web. Veți studia o pagină simplă de conversie valutară care demonstrează cum să convertiți HTML obișnuit
într-un ASP dinamic. Pagină web alimentată de NET. Apoi veți explora modelul paginii web și veți dobândi abilitățile de care
aveți nevoie pentru a crea controale din mers, pentru a naviga de la o pagină la alta și pentru a gestiona caractere speciale
în HTML. În cele din urmă, veți lua în considerare modelul de configurare ASP.NET.

Anatomia unei aplicații ASP.NET

Uneori este dificil să definiți exact ce este o aplicație web. Spre deosebire de un program desktop tradițional (pe care
utilizatorii îl încep prin rularea unui fișier EXE independent), ASP.NET aplicații sunt aproape întotdeauna împărțite în mai
multe pagini web. Această diviziune înseamnă că un utilizator poate intra într-o aplicație ASP.NET în mai multe puncte
diferite sau poate urma un link din aplicație către o altă parte a site-ului web sau un alt server web. Deci, are sens să
considerăm un site web ca o aplicație?
În ASP.NET, răspunsul este da. Fiecare aplicație ASP.NET partajează un set comun de resurse și setări de
configurare. Paginile web din alte aplicații ASP.NET nu partajează aceste resurse, chiar dacă se află pe același
server web. Din punct de vedere tehnic, fiecare aplicație ASP.NET este executată într-un domeniu de aplicație
separat. Domeniile de aplicații sunt zone izolate din memorie și asigură că, chiar dacă o aplicație web provoacă
o eroare fatală, este puțin probabil să afecteze orice altă aplicație care rulează în prezent pe același computer (în
acest caz, acesta este serverul web). În mod similar, domeniile de aplicații restricționează o pagină web dintr-o
aplicație să acceseze informațiile din memorie ale unei alte aplicații. Fiecare aplicație web este întreținută separat
și are propriul set de date memorate în cache, aplicații și sesiuni.
Definiția standard a unei aplicații ASP.NET o descrie ca o combinație de fișiere, pagini, handlere, module și cod
executabil care pot fi invocate dintr-un director virtual (și, opțional, subdirectoarele sale) pe un server web. Cu alte
cuvinte, directorul virtual este structura de grupare de bază care delimitează o aplicație. Figura 5-1 prezintă un server
web care găzduiește patru aplicații web separate.

Notăun
• este Undirector
directorexpus
virtualpublicului pe un server Web. După cum veți descoperi în capitolul
26, implementați aplicația web ASP.NET perfecționată copiind-o într-un director virtual.

127
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5
Descărcați de la Wow! eBook <www.wowebook.com>

Figura 5-1. ASP.NET aplicații

ASP.NET tipuri de fișiere

ASP.NET aplicații pot include mai multe tipuri de fișiere. Tabelul 5-1 prezintă ingredientele esențiale.

Tabelul 5-1. ASP.NET tipuri de fișiere

Nume fișier Descriere

Se termină cu Acestea sunt pagini web ASP.NET (echivalentul .NET al fișierului .asp într-o
.aspx aplicație ASP). Acestea conțin interfața cu utilizatorul și, opțional, codul aplicației
subiacente. Utilizatorii solicită sau navighează direct la una dintre aceste pagini
pentru a porni aplicația web.
Se termină cu Acestea sunt ASP.NET controale ale utilizatorului. Controalele utilizatorului sunt similare cu
.ascx paginile web, cu excepția faptului că utilizatorul nu poate accesa direct aceste fișiere. În schimb,
acestea trebuie găzduite într-o pagină web ASP.NET. Controalele utilizatorului vă permit să
dezvoltați o mică bucată de interfață cu utilizatorul și să o reutilizați în câte formulare web doriți,
fără cod repetitiv. Veți afla despre comenzile utilizatorilor în capitolul 11.

128
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Nume fișier Descriere

web.config Acesta este fișierul de configurare bazat pe XML pentru aplicația ASP.NET. Acesta include:
Setări pentru particularizarea securității, gestionarea stării, gestionarea memoriei și
mult mai mult. Veți primi o introducere în fișierul web.config în acest capitol și
Veți explora setările sale pe parcursul acestei cărți.
global.asax Acesta este fișierul global de aplicare. Puteți utiliza acest fișier pentru a defini variabile globale
(variabile care pot fi accesate de pe orice pagină web din aplicația web) și
reacționează la evenimente globale (cum ar fi atunci când pornește pentru prima dată o aplicație web). Vei învăța
despre aceasta mai târziu în acest capitol.
Se termină cu .cs Acestea sunt fișiere din spatele codului care conțin cod C #. Acestea vă permit să separați
logica aplicației din interfața cu utilizatorul a unei pagini web. Vom introduce codul-
în spatele modelului din acest capitol și folosiți-l pe larg în această carte.

În plus, aplicația web poate conține alte resurse care nu sunt fișiere ASP.NET speciale. De exemplu,
directorul virtual poate conține fișiere imagine, fișiere HTML sau foi de stil CSS. Aceste resurse pot fi utilizate
într-una dintre ASP.NET pagini web sau pot fi utilizate independent. Un site web ar putea chiar să combine
pagini HTML statice cu pagini ASP.NET dinamice.

ASP.NET directoare de aplicații

Fiecare aplicație web ar trebui să aibă o structură de directoare bine planificată. De exemplu, probabil că veți dori să
stocați imagini într-un folder separat de locul în care stocați paginile web. Sau poate doriți să puneți paginile ASP.NET
publice într-un folder și cele restricționate în altul, astfel încât să puteți aplica setări de securitate diferite în funcție de
director. (Consultați capitolul 19 pentru mai multe informații despre cum să creați reguli de autorizare ca aceasta.)

Împreună cu directoarele pe care le creați, ASP.NET utilizează, de asemenea, câteva subfoldere

specializate, pe care le recunoaște după nume (consultați tabelul 5-2). Rețineți că nu veți vedea toate
aceste subfoldere într-o aplicație tipică. Visual Studio vă va solicita să le creați după cum este necesar.
Tabelul 5-2. ASP.NET directoare

Director Descriere
App_Browsers Conține fișiere .browser pe care ASP.NET le utilizează pentru a identifica browserele
care utilizează aplicația și pentru a determina capacitățile acestora. De obicei, informațiile
browserului sunt standardizate pe întregul server web și nu este necesar să utilizați acest
folder. Pentru mai multe informații despre suportul browserului ASP.NET - care este o
caracteristică avansată pe care majoritatea dezvoltatorilor web obișnuiți o pot ignora în
siguranță - consultați Pro ASP.NET 4 în C# 2010 (Apress).

App_Code Conține fișiere de cod sursă care sunt compilate dinamic pentru a fi utilizate
în aplicația dvs.
App_GlobalResources Stochează resurse globale care sunt accesibile fiecărei pagini din aplicația web.
Acest director este utilizat în scenarii de localizare, atunci când trebuie să aveți un
site web în mai multe limbi. Localizarea nu este acoperită în această carte, deși puteți
consulta Pro ASP.NET 4 în C# 2010 (Apress) pentru mai multe informații.

129
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Director Descriere

App_LocalResources Servește aceluiași scop ca App_GlobalResources, cu excepția faptului că aceste

resurse sunt accesibile numai unei anumite pagini.

App_WebReferences Stochează referințe la servicii web, care sunt rutine de cod la distanță pe care o
aplicație web le poate apela printr-o rețea sau prin Internet.

App_Data Stochează date, inclusiv fișiere de baze de date SQL Server Express (după
cum veți vedea în capitolul 14). Desigur, sunteți liber să stocați fișiere de date în
alte directoare.
App_Themes Stochează temele utilizate pentru standardizarea și reutilizarea formatării în
aplicația web. Veți afla despre teme în capitolul 12.

Bin Conține toate componentele .NET compilate (DLL) pe care le utilizează aplicația
web ASP.NET. De exemplu, dacă dezvoltați o componentă particularizată pentru
accesarea unei baze de date (consultați capitolul 22), veți plasa componenta aici.
ASP.NET va detecta automat ansamblul și orice pagină din aplicația web îl va
putea utiliza. Acest model de implementare fără probleme este mult mai ușor
decât lucrul cu componentele COM tradiționale, care trebuie înregistrate înainte
de a putea fi utilizate (și adesea reînregistrate atunci când se schimbă).

Vă prezentăm controalele serverului

ASP.NET introduce un nou model remarcabil pentru crearea paginilor web. În dezvoltarea web în stil vechi,
programatorii trebuiau să stăpânească ciudățeniile și detaliile HTML înainte de a putea proiecta o pagină web
dinamică. Paginile trebuiau să fie adaptate cu atenție la o anumită sarcină, iar singura modalitate de a genera
conținut suplimentar era generarea de etichete HTML brute.
ASP.NET rezolvă această problemă cu un model de nivel superior de controale de server. Aceste controale sunt create
și configurate ca obiecte. Acestea rulează pe serverul web și oferă automat propria ieșire HTML. Chiar mai bine,
controalele serverului se comportă ca omologii lor Windows, menținând starea și ridicând evenimente la care puteți
reacționa în cod.
În capitolul anterior, ați construit o pagină web extrem de simplă care a încorporat câteva controale pe care
le-ați tras din caseta de instrumente Visual Studio. Dar, înainte de a crea o pagină mai complexă, merită să
faceți un pas înapoi pentru a privi imaginea de ansamblu. ASP.NET oferă de fapt două seturi de controale
pe partea de server pe care le puteți încorpora în formularele dvs. Aceste două tipuri diferite de controale
joacă roluri subtil diferite:
Controale server HTML: Acestea sunt echivalente bazate pe server pentru elemente HTML standard.
Aceste controale sunt ideale dacă sunteți un programator web experimentat care preferă să lucreze
cu etichete HTML familiare (cel puțin la început). Ele sunt, de asemenea, utile atunci când migrați
pagini HTML obișnuite sau pagini ASP în ASP.NET, deoarece necesită cele mai puține modificări.
Controale web: Acestea sunt similare cu controalele serverului HTML, dar oferă un model de obiect mai
bogat, cu o varietate de proprietăți pentru detalii de stil și formatare. De asemenea, oferă mai multe
evenimente și seamănă mai mult cu controalele utilizate pentru dezvoltarea Windows. Controalele web
prezintă, de asemenea, unele elemente de interfață utilizator care nu au echivalent HTML direct, cum ar
fi controalele GridView, Calendar și validare.

130
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Veți afla despre controalele web în capitolul următor. În acest capitol, veți arunca o privire detaliată
asupra controalelor serverului HTML.

Notă Chiar dacă intenționați să utilizați exclusiv controale web, merită să citiți această secțiune pentru a stăpâni
•
elementele de bază ale controalelor HTML. Pe parcurs, veți primi o introducere în câteva
elemente esențiale ASP.NET care se aplică tuturor tipurilor de controale ale serverului, inclusiv
starea vizualizării, postback-urile și gestionarea evenimentelor.

Controale server HTML

Controalele serverului HTML oferă o interfață obiect pentru elementele HTML standard. Acestea oferă trei
caracteristici cheie:

Acestea generează propria interfață: setați proprietățile în cod, iar eticheta HTML subiacentă este
creată automat atunci când pagina este redată și trimisă clientului.
Ele își păstrează starea: Deoarece Web-ul este apatrid, paginile web obișnuite trebuie să facă multă muncă
pentru a stoca informații între cereri. Controalele serverului HTML gestionează automat această sarcină. De
exemplu, dacă utilizatorul selectează un element dintr-o casetă listă, acel element rămâne selectat data
viitoare când este generată pagina. Sau, în cazul în care codul modifică textul dintr-un buton, noul text se
lipește data viitoare când pagina este postată înapoi pe serverul web.
Acestea declanșează evenimente pe partea serverului: De exemplu, butoanele declanșează un eveniment atunci
când se face clic, casetele de text declanșează un eveniment atunci când textul pe care îl conțin este modificat și
așa mai departe. Codul dvs. poate răspunde la aceste evenimente, la fel ca controalele obișnuite dintr-o aplicație
Windows. În codul ASP, totul este grupat într-un singur bloc care se execută de la început până la sfârșit. Cu
programarea bazată pe evenimente, puteți răspunde cu ușurință la acțiunile individuale ale utilizatorilor și puteți
crea cod mai structurat. Dacă nu are loc un anumit eveniment, rutina de tratare a evenimentelor nu va fi executată.

Controalele serverului HTML sunt ideale atunci când efectuați o traducere rapidă pentru a adăuga cod la
nivelul serverului la o pagină HTML existentă. Aceasta este sarcina pe care o veți aborda în secțiunea
următoare, cu o aplicație web simplă de o pagină.

Conversia unei pagini HTML într-o pagină ASP.NET

Figura 5-2 prezintă o pagină web a convertorului valutar. Permite utilizatorului să convertească un număr de
dolari americani la suma echivalentă de euro - sau cel puțin ar face-o, dacă ar avea codul necesar pentru a
face treaba. Chiar acum, este doar o pagină HTML simplă, inertă. Nu se întâmplă nimic când se face clic pe
buton.

131
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Figura 5-2. Un convertor valutar simplu

Următoarea listă arată marcajul pentru această pagină. Pentru a fi cât mai clar posibil, această listă omite atributul de
stil al elementului <div> utilizat pentru chenar. Această pagină are două elemente <intrare>: unul pentru caseta de text
și unul pentru butonul de trimitere. Aceste elemente sunt incluse într-o etichetă <formular>, astfel încât să poată trimite
informații serverului atunci când se face clic pe buton. Restul paginii constă din text static. &nbsp; Entitatea caracter
este utilizată pentru a adăuga un spațiu suplimentar pentru a separa controalele. Un doctype din partea de sus a
paginii declară că este scris în conformitate cu regulile stricte de marcare din XHTML 1.1.

<! DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML

1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head> <title>Convertor valutar</title> </head>
<body> <form method="post"> <div>
Convertiți:&nbsp; <input type="text" /> dolari
americani în euro. <br /><br />

<input type="submit" value="OK" /> </div>

</form> </body> </html>

132
 CAPITOLUL FUNDAMENTELE
5 FORMULARELOR
WEB

Notă În HTML toate controalele de intrare sunt reprezentate cu elementul <intrare>. Setați atributul type la
•
Indicați tipul de control dorit. Eticheta <input type="text"> este o casetă text, în timp ce <input
type="submit"> creează un buton de trimitere pentru trimiterea paginii web înapoi la serverul
web. Acest lucru este destul de diferit de controalele web pe care le veți vedea în capitolul 6,
care utilizează un element diferit pentru fiecare tip de control.

În prezent, această pagină arată frumos, dar nu oferă nicio funcționalitate. Se compune în întregime din interfața cu
utilizatorul (elemente HTML) și nu conține cod. Este o pagină HTML obișnuită, nu un formular web. Cel mai simplu mod de
a converti convertorul valutar în ASP.NET este să începeți prin generarea unui nou formular web în Visual Studio. Pentru
aceasta, selectați Adăugare element nou pe site-ul web. În caseta de dialog Adăugare element nou,
→ selectați Formular web, introduceți un nume pentru pagina nouă (cum ar fi CurrencyConverter.aspx), asigurați-vă
că este bifată opțiunea Cod de locație în fișier separat și faceți clic pe Adăugare pentru a crea pagina.
În noul formular web, ștergeți tot ce se află în prezent în fișierul .aspx, cu excepția directivei privind paginile. Directiva
privind paginile oferă ASP.NET informații de bază despre modul de compilare a paginii. Acesta indică limba pe care o
folosești pentru cod și modul în care conectezi rutinele de tratare a evenimentelor. Dacă folosiți abordarea
code-behind, care este recomandată, directiva privind paginile indică și unde se află fișierul de cod și numele clasei de
pagini personalizate.
În cele din urmă, copiați tot conținutul din pagina HTML originală și lipiți-l în noua pagină, imediat după
directiva paginii. Iată formularul web rezultat, cu directiva paginii (cu caractere aldine) urmată de conținutul
HTML copiat din pagina originală:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="CurrencyConverter.aspx.cs" mostenit="CurrencyConverter" %>

<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML

1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <html
xmlns="http://www.w3.org/1999/xhtml"> <head>
<title>Convertor valutar</title> </head> <body> <form
method="post"> <div> Convertire: &nbsp; <input
type="text" /> &nbsp; Dolari SUA în euro. <br /><br />

<input type="submit" value="OK" /> </div>

</form> </body> </html>

Acum trebuie să adăugați atributul runat = "server" la fiecare etichetă pe care doriți să o transformați într-un control al
serverului. De asemenea, ar trebui să adăugați un atribut ID la fiecare control cu care trebuie să interacționați în cod.
Atributul ID atribuie numele unic pe care îl veți folosi pentru a face referire la control în cod.
În aplicația convertor valutar, este logic să schimbați caseta de text de intrare și butonul de trimitere în
controalele serverului HTML. În plus, elementul <formular> trebuie procesat ca un control de server pentru
a ASP.NET permite să acceseze controalele pe care le conține. Iată pagina completă, modificată corect:
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

<%@ Page Language="C#" AutoEventWireup="true"

CodeFile="CurrencyConverter.aspx.cs" mostenit="CurrencyConverter" %>

<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML

1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <html
xmlns="http://www.w3.org/1999/xhtml"> <head>
<title>Convertor valutar</title> </head> <body> <form >

runat
= "server" < div>
Convertire: &nbsp; <input
type="text"
ID="US" runat="server" /> &nbsp; dolari
americani către euro. <br /><br />

<input type="submit" value="OK" />

ID="Convertit" runat="server" </div> </form> </body> </html>

Notă Majoritatea controalelor ASP.NET trebuie plasate în secțiunea <formular> din pagină. Elementul <formă> este un
•
face parte din standardul pentru formularele HTML și permite browserului să trimită informații
către serverul web.

Pagina web tot nu va face nimic atunci când o rulați, deoarece nu ați scris niciun cod. Cu toate acestea,
acum că ați convertit elementele HTML statice în controale de server HTML, sunteți gata să lucrați cu ele.

Vizualizare stare
Pentru a încerca această pagină, lansați-o în Visual Studio apăsând F5. Amintiți-vă, prima dată când executați aplicația web, vi se va solicita să permiteți Visual Studio să
modifice fișierul web.config pentru a permite depanarea. Faceți clic pe OK pentru a accepta recomandarea și a lansa pagina web în browser. Apoi, selectați Vizualizare

→ Sursă în browser pentru a vedea codul HTML pe care vi l-ASP.NET trimis.

Primul lucru pe care îl veți observa este că codul HTML care a fost trimis browserului este ușor diferit de
informațiile din fișierul .aspx. În primul rând, atributele runat = "server" sunt eliminate (deoarece nu au nicio
semnificație pentru browserul client, care nu le poate interpreta). În al doilea rând, și mai important, un
câmp ascuns suplimentar a fost adăugat la formular. Iată ce veți vedea (într-o formă ușor simplificată):

<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML

1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <html
xmlns="http://www.w3.org/1999/xhtml"> <head>
<title>Convertor valutar</title> </head>

134
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

<body> <form id="form1" method="post" action="CurrencyConverter.aspx">

<div>

<input type="hidden" ID="__VIEWSTATE" name="__VIEWSTATE" value="dDw3NDg2NTI5MDg7Oz4=" /> </div>

<div> Convertiți: &nbsp; <input type="text" ID="US" name="US" /> &nbsp; dolari americani în euro.

<br /><br /> <input type="submit" value="OK" ID="Convert" name="Convert" />

</div> </form> </body> </html>

Acest câmp ascuns stochează informații, într-un format comprimat, despre starea fiecărui control din pagină. Vă permite
să manipulați proprietățile de control în cod și să persistați automat modificările pe parcursul mai multor călătorii de la
browser la serverul web. Aceasta este o parte esențială a modelului de programare a formularelor web. Datorită stării de
vizualizare, puteți uita adesea de natura apatridă a internetului și vă puteți trata pagina ca pe o aplicație care rulează
continuu.
Chiar dacă programul de conversie valutară nu include încă niciun cod, veți observa deja o modificare. Dacă
introduceți informații în caseta text și faceți clic pe butonul trimitere pentru a publica pagina, pagina
reîmprospătată va conține în continuare valoarea pe care ați introdus-o în caseta text. (În exemplul original
care utilizează elemente HTML obișnuite, valoarea va fi ștearsă de fiecare dată când pagina este trimisă.)
Această modificare se produce deoarece controalele ASP.NET își păstrează automat starea.

Clasele de control HTML

Înainte de a putea continua cu convertorul valutar, trebuie să știți despre obiectele de control pe care le-ați
creat. Toate controalele serverului HTML sunt definite în spațiul de nume System.Web.UI.HtmlControale.
Fiecare tip de control are o clasă separată. Tabelul 5-3 descrie controalele de bază ale serverului HTML și
vă arată elementul HTML asociat.
Tabelul 5-3. Clasele de control ale serverului HTML

Numele clasei HTML Element Descriere

HtmlForm <formă> Împachetează toate controalele de pe o pagină web. Toate

controalele ASP.NET server trebuie plasate într-un control
HtmlForm, astfel încât să își poată trimite datele către server
atunci când pagina este trimisă. Visual Studio adaugă
elementul <formular> la toate paginile noi. Când proiectați o
pagină web, trebuie să vă asigurați că fiecare alt control pe
care îl adăugați este plasat în secțiunea <formular>.

HtmlAnchor <a> Un hyperlink pe care utilizatorul face clic pentru a

sări la altă pagină.

135
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Numele clasei HTML Element Descriere

HtmlImage <IMG> Un link care indică o imagine, care va fi inserată în

pagina web în locația curentă.

HtmlTable, <tabel>, <tr>, <th> Un tabel care afișează mai multe rânduri și coloane
HtmlTableRow și și <td> de text static.
HtmlTableCell

HtmlInputButton, <input Un buton pe care utilizatorul face clic pentru a

HtmlInputRemiteți și type="button">, efectua o acțiune (HtmlInputButton), pentru a trimite
HtmlInputReset <input pagina (HtmlInputSubmit) sau pentru a șterge toate
type="submit"> și valorile furnizate de utilizator în toate controalele
<input (HtmlInputReset).
type="reset">
HtmlButton <buton> Un buton pe care utilizatorul face clic pentru a efectua
o acțiune. Acest lucru nu este acceptat de toate
browserele, deci HtmlInputButton este de obicei
folosit în schimb. Diferența cheie este că HtmlButton
este un element container. Drept urmare, puteți
insera aproape orice în interiorul acestuia, inclusiv
text și imagini. HtmlInputButton, pe de altă parte, este
strict text.
HtmlInputCheckBox <input type="caseta O casetă de selectare pe care utilizatorul o poate bifa
de selectare"> sau debifa. Nu include niciun text propriu.

HtmlInputRadioButton <input Un buton radio care poate fi selectat într-un

type="radio"> grup. Nu include niciun text propriu.

HtmlInputText și <input type="text"> O casetă text cu o singură linie în care utilizatorul

HtmlInputPassword și <input poate introduce informații. Poate fi afișat și ca un
type="password"> câmp de parolă (care afișează marcatori în loc de
caractere pentru a ascunde intrarea utilizatorului).

HtmlTextArea <textarea> O casetă de text mare în care utilizatorul poate tasta mai
multe linii de text.

HtmlInputImage <input Similar cu eticheta <img>, dar inserează o imagine "pe

type="image"> care se poate face clic" care trimite pagina. Folosind
codul de pe server, puteți determina exact unde a făcut
clic utilizatorul în imagine - o tehnică pe care o veți lua în
considerare mai târziu în acest capitol.

HtmlInputFile <input type="fișier"> Un buton Răsfoire și o casetă text care pot fi

utilizate pentru a încărca un fișier pe serverul dvs.
web, așa cum este descris în capitolul 17.

136
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Numele clasei HTML Element Descriere

HtmlInputHidden <input Conține informații text care vor fi trimise la server
type="ascuns"> atunci când pagina este postată înapoi, dar nu vor
fi vizibile în browser.
HtmlSelect <selectați> O casetă verticală sau o casetă listă obișnuită în care
utilizatorul poate selecta un element.
HtmlHead și <cap> și <titlu> Reprezintă informațiile de antet pentru pagină, care
HtmlTitle includ informații despre pagină care nu sunt afișate
efectiv în pagină, cum ar fi cuvintele cheie de căutare și
titlul paginii web. Acestea sunt singurele controale de
server HTML care nu sunt plasate în secțiunea
<formular>.
HtmlGenericControl Orice alt element Acest control poate reprezenta o varietate de elemente
HTML. HTML care nu au clase de control dedicate. De exemplu,
dacă adăugați atributul runat="server" la un element <div>,
acesta este furnizat codului ca obiect HtmlGenericControl.
Puteți identifica tipul de element citind proprietatea
TagName, care stochează un șir (de exemplu, "div").

Amintiți-vă, există două moduri de a adăuga orice control de server HTML. Puteți să-l adăugați manual la marcajul din
fișierul .aspx (pur și simplu introduceți elementul HTML obișnuit și adăugați atributul runat = "server"). Alternativ,
puteți trage controlul din fila HTML a Toolbox și îl puteți fixa pe suprafața de proiectare a unei pagini web din Visual
Studio. Această abordare nu funcționează pentru fiecare control de server HTML, deoarece nu apar toate în fila
HTML.
Până în prezent, convertorul valutar definește trei controale, care sunt instanțe ale claselor HtmlForm,
HtmlInputText și, respectiv, HtmlInputButton. Este util să cunoașteți numele claselor dacă doriți să căutați
informații despre aceste clase în Ajutorul Visual Studio. Tabelul 5-4 oferă o prezentare rapidă a unora
dintre cele mai importante proprietăți de control.
Tabelul 5-4. Proprietăți importante de control HTML

Controla Cele mai importante proprietăți

HtmlAnchor HRef, nume, țintă, titlu
HtmlImage Src, Alt, Aliniere, Bordură, Lățime, Înălțime

HtmlInputCheckBox și HtmlInputRadioButton Verificat

HtmlInputText Valoare

HtmlTextArea Valoare

HtmlInputImage Src, Alt, Aliniere, Frontieră

HtmlSelect Articole (colecție)

HtmlGenericControl InnerText și InnerHtml

137
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Adăugarea codului convertorului valutar

Pentru a adăuga de fapt unele funcționalități convertorului valutar, trebuie să adăugați un cod ASP.NET. Formularele
web sunt determinate de evenimente, ceea ce înseamnă că fiecare bucată de cod acționează ca răspuns la un anumit
eveniment. În exemplul de pagină convertor valutar simplu, cel mai util eveniment apare atunci când utilizatorul face
clic pe butonul de trimitere (numit Conversie). HtmlInputButton vă permite să reacționați la această acțiune gestionând
evenimentul ServerClick.
Înainte de a continua, este logic să adăugați un alt control care poate afișa rezultatul calculului. În acest
caz, puteți utiliza un element <p> numit Rezultat. Elementul <p> este o modalitate de a insera un bloc de
text formatat într-o pagină web. Iată codul HTML de care veți avea nevoie:
<p style="font-weight: bold" ID="Rezultat" runat="server">/p>
Atributul style aplică proprietățile CSS utilizate pentru formatarea textului. În acest exemplu, aplică doar un
font aldin.
Exemplul are acum următoarele patru controale de server:
• Un formular (obiect HtmlForm). Acesta este singurul control pe care nu trebuie
să-l accesați în clasa dvs.
• O casetă de text de intrare numită US (obiect HtmlInputText).
• Un buton de trimitere numit Conversie (obiect HtmlInputButton).
• Un element <p> numit Result (obiect HtmlGenericControl).
Listarea 5-1 afișează pagina web revizuită (CurrencyConverter.aspx), dar omite doctipul pentru a economisi
spațiu. Listarea 5-2 arată clasa din spatele codului (CurrencyConverter.aspx.cs). Clasa din spatele codului
include o rutină de tratare a evenimentelor care reacționează atunci când se face clic pe butonul de conversie.
Calculează conversia valutară și afișează rezultatul.

Lista 5-1. CurrencyConverter.aspx

<%@ Page language="C#" AutoEventWireup="true"

CodeFile="CurrencyConverter.aspx.cs" mosteniti="CurrencyConverter" %> <html
xmlns="http://www.w3.org/1999/xhtml"> <head> <title>Convertor valutar</title>
</head> <body> <form runat="server"> <div> Convertire: &nbsp; <input type="text"
ID="US" runat="server" /> &nbsp; Dolari SUA în euro.

<br /><br /> <input type="submit" value="OK" ID="Convert" runat="server"

OnServerClick ="Convert_ServerClick" /> <br /><br /> <p style="font-weight:
bold" ID="Result" runat="server"></p> </div> </form> </body> </html>

138
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Lista 5-2. CurrencyConverter.aspx.cs

folosind Sistem; folosind

System.Collections.Generic; folosind
System.Linq; folosind System.Web;
folosind System.Web.UI; folosind
System.Web.UI.WebControls;

public clasa parțială CurrencyConverter : System.Web.UI.Page { protejat void Convert_ServerClick(expeditor obiect, EventArgs e)
{ zecimal USAmount = Decimal.Parse(US. valoare); zecimal euroAmount = USAmount * 0.85M; Result.InnerText =
USAmount.ToString() + " dolari americani = "; } Result.InnerText += euroAmount.ToString() + " Euro."; }

Clasa din spatele codului este un exemplu tipic de pagină ASP.NET. Veți observa următoarele
convenții:
• Începe cu mai multe declarații de utilizare. Aceasta oferă acces la toate spațiile de
nume importante. Acesta este un prim pas tipic în orice fișier din spatele codului.
• Clasa de pagini este definită cu cuvântul cheie parțial. Acest lucru se întâmplă deoarece
codul clasei este îmbinat cu un alt fișier de cod pe care nu îl vedeți niciodată. Acest cod
suplimentar, pe care ASP.NET generează automat, definește toate controalele serverului care
sunt utilizate pe pagină. Acest lucru vă permite să le accesați după nume în codul dvs.
• Pagina definește un singur operator de evenimente. Această rutină de tratare a
evenimentelor preia valoarea din caseta text, o convertește într-o valoare numerică, o
înmulțește cu un raport de conversie prestabilit (care ar fi stocat de obicei într-un alt fișier sau
într-o bază de date) și setează textul elementului <p>. Veți observa că rutina de tratare a
evenimentelor acceptă doi parametri (expeditor și e). Acesta este standardul .NET pentru
toate evenimentele de control. Permite codului dvs. să identifice controlul care a trimis
evenimentul (prin parametrul expeditorului) și să preia orice alte informații care pot fi asociate
cu evenimentul (prin parametrul e). Veți vedea exemple ale acestor tehnici avansate în
capitolul următor, dar deocamdată este important să vă dați seama că nu vi se va permite să
gestionați un eveniment decât dacă rutina de tratare a evenimentelor are semnătura corectă,
potrivită.
• Rutina de tratare a evenimentelor este conectată la evenimentul de control
utilizând atributul OnServerClick din eticheta <input> pentru buton. Veți afla mai
multe despre cum funcționează această conectare în secțiunea următoare.

139
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Notă Spre deosebire de controalele web, nu puteți crea rutine de tratare a evenimentelor pentru controalele serverului HTML utilizând Proprietăți
•
fereastră. În schimb, trebuie să tastați metoda manual. De asemenea, trebuie să modificați eticheta de control pentru a conecta rutina de
tratare a evenimentelor. De exemplu, pentru a conecta butonul Conversie la metoda numită Convert_ServerClick, trebuie să adăugați

OnServerClick = "Convert_ServerClick" la eticheta de control.

• Operatorul += este utilizat pentru a adăuga rapid informații la sfârșitul etichetei, fără a
înlocui textul existent.
• Rutina de tratare a evenimentelor utilizează ToString() pentru a efectua conversia valorii
zecimale în text, astfel încât să poată fi adăugată la proprietatea InnerText. În această
afirmație, nu aveți nevoie de ToString(), deoarece C# este suficient de inteligent pentru a
realiza că uniți bucăți de text. Cu toate acestea, acest lucru nu se întâmplă întotdeauna,
deci este mai bine să fiți explicit cu privire la conversiile tipurilor de date.
Puteți lansa această pagină pentru a vă testa codul. Când introduceți o valoare și faceți clic pe butonul OK,
pagina este retrimisă, se execută codul de gestionare a evenimentelor și vi se returnează pagina cu detaliile
conversiei (consultați Figura 5-3).

Figura 5-3. Convertorul valutar ASP.NET

Gestionarea evenimentelor
Când utilizatorul face clic pe butonul Conversie și pagina este trimisă înapoi la serverul web, ASP.NET
trebuie să știți exact ce cod doriți să rulați. Pentru a crea această relație și a conecta un eveniment la o
metodă de gestionare a evenimentelor, trebuie să adăugați un atribut în eticheta de control.

140
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

De exemplu, dacă doriți să gestionați metoda ServerClick a butonului Conversie, trebuie pur și simplu să
setați atributul OnServerClick în eticheta de control cu numele rutinei de tratare a evenimentelor pe care
doriți să o utilizați:
<input type="submit" value="OK" ID="Convert" OnServerClick
="Convert_ServerClick" runat="server">

ASP.NET controale utilizează întotdeauna această sintaxă. Când atașați o rutină de tratare a evenimentelor în
eticheta de control, utilizați numele evenimentului precedat de cuvântul Activat. De exemplu, dacă doriți să
gestionați un eveniment numit ServerChange, trebuie să setați un atribut în eticheta de control numit
OnServerChange. Când faceți dublu clic pe un control server pe suprafața de proiectare, Visual Studio
adaugă rutina de tratare a evenimentelor și setează atributul evenimentului să se potrivească. (Acum că
înțelegeți acest proces, veți înțelege sursa unei erori comune. Dacă faceți dublu clic pe un control pentru a
crea o rutină de tratare a evenimentelor, dar apoi ștergeți metoda de gestionare a evenimentelor, veți obține
un atribut de eveniment care indică un eveniment inexistent. Prin urmare, veți primi o eroare data viitoare
când rulați pagina. Pentru a remedia problema, trebuie să eliminați atributul evenimentului din eticheta de
control.)

• Notă Există un obiect ASP.NET care nu utilizează acest sistem de atribute, deoarece nu are o
etichetă de control - pagina web. În schimb, ASP.NET conectează evenimentele paginii web pe
baza numelor metodelor. Cu alte cuvinte, dacă aveți o metodă numită Page_Load() în clasa de
pagini și are semnătura corectă (acceptă doi parametri, un obiect reprezentând expeditorul și un
obiect EventArgs), ASP.NET conectează automat această rutină de tratare a evenimentelor la
evenimentul Page.Load. Această caracteristică se numește wireup automat de evenimente.

ASP.NET vă permite să utilizați o altă tehnică pentru a conecta evenimente - o puteți face folosind cod, așa
cum ați văzut în capitolul 3. De exemplu, iată codul necesar pentru a conecta evenimentul ServerClick al
butonului Conversie folosind cablarea manuală a evenimentelor:
Convert.ServerClick + = acest. Convert_ServerClick;
Dacă utilizați un astfel de cod, probabil că îl veți adăuga la Page_Load(), astfel încât să conecteze rutinele de
tratare a evenimentelor atunci când pagina este inițializată pentru prima dată.
Având în vedere că Visual Studio gestionează cablarea evenimentelor, de ce ar trebui să le pese
dezvoltatorilor ASP.NET că au două modalități de a conecta un operator de evenimente? Ei bine, de cele
mai multe ori nu vă veți face griji. Dar tehnica manuală de cablare a evenimentelor este utilă în anumite
circumstanțe. Cel mai frecvent exemplu este dacă doriți să creați un obiect de control și să îl adăugați
dinamic la o pagină în timpul rulării. În această situație, nu puteți conecta rutina de tratare a evenimentelor
prin eticheta de control, deoarece nu există o etichetă de control. În schimb, trebuie să creați controlul și să
atașați gestionarii de evenimente folosind codul. (Capitolul următor conține un exemplu despre cum puteți
utiliza crearea controlului dinamic pentru a completa un tabel.)

141
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

În culise cu convertorul valutar

Deci, ce se întâmplă cu adevărat atunci când ASP.NET primește o cerere pentru pagina de
CurrencyConverter.aspx? Procesul se desfășoară de fapt în mai mulți pași:
1. În primul rând, cererea pentru pagină este trimisă serverului web. Dacă rulați un
site live, serverul web este aproape sigur IIS, despre care veți afla mai multe în
capitolul 26. Dacă executați pagina în Visual Studio, solicitarea este trimisă
serverului de testare încorporat.
2. Serverul web determină că extensia de fișier .aspx este înregistrată cu
ASP.NET. Dacă extensia de fișier ar aparține unui alt serviciu (așa cum ar fi
pentru fișierele .asp sau .html), ASP.NET nu s-ar implica niciodată.
3. Dacă este prima dată când o pagină din această aplicație a fost solicitată,
ASP.NET creează automat domeniul aplicației. De asemenea, compilează tot
codul paginii web pentru performanțe optime și memorează în cache fișierele
compilate. Dacă această sarcină a fost deja efectuată, ASP.NET va reutiliza
versiunea compilată a paginii.
4. Pagina de CurrencyConverter.aspx compilată acționează ca un program în miniatură. Începe
să declanșeze evenimente (în special, evenimentul Page.Load). Cu toate acestea, nu ați creat
o rutină de tratare a evenimentelor pentru acel eveniment, deci nu rulează niciun cod. În acest
stadiu, totul funcționează împreună ca un set de obiecte .NET în memorie.

5. Când codul este terminat, ASP.NET cere fiecărui control din pagina web să
se redea în marcajul HTML corespunzător.

Sfat
• De fapt, ASP.NET efectuează o mică manevră și poate personaliza ieșirea cu JavaScript sau
DHTML suplimentar pe partea client dacă detectează că browserul client o acceptă. În cazul
CurrencyConverter.aspx, ieșirea paginii este prea simplă pentru a necesita acest tip de ajustare
automată.

6. Pagina finală este trimisă utilizatorului, iar aplicația se încheie.

Descrierea este lungă, dar este important să începeți cu o bună înțelegere a elementelor fundamentale.
Când faceți clic pe un buton de pe pagină, întregul proces se repetă. Cu toate acestea, în pasul 4
evenimentul ServerClick se declanșează pentru HtmlInputButton imediat după evenimentul Page.Load și se
execută codul. Figura 5-4 ilustrează etapele unei solicitări de pagină web.

142
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Figura 5-4. Etapele unei solicitări ASP.NET

Cel mai important detaliu este că codul dvs. funcționează cu obiecte. Ultimul pas este transformarea acestor
obiecte în ieșirea HTML corespunzătoare. O conversie similară de la obiecte la ieșire se întâmplă cu un
program Windows în .NET, dar este atât de automat încât programatorii rareori se gândesc prea mult. De
asemenea, în aceste medii, codul rulează întotdeauna local. Într-o aplicație ASP.NET, codul rulează într-un
mediu protejat pe server. Clientul vede rezultatele numai după ce procesarea paginii web s-a încheiat și
obiectul paginii web a fost eliberat din memorie.

143
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Tratarea erorilor
Convertorul valutar se așteaptă ca utilizatorul să introducă un număr înainte de a face clic pe butonul Conversie. Dacă
utilizatorul introduce altceva - de exemplu, o secvență de text sau caractere speciale care nu pot fi interpretate ca
număr - va apărea o eroare atunci când codul încearcă să utilizeze metoda Decimal.Parse(). În versiunea curentă a
convertorului valutar, această eroare va deraia complet codul de gestionare a evenimentelor. Deoarece acest exemplu
nu include niciun cod pentru tratarea erorilor, ASP.NET va trimite pur și simplu o pagină de eroare înapoi utilizatorului
care descrie problema.
În capitolul 7, veți învăța cum să faceți față erorilor prinzându-le, neutralizându-le și informând utilizatorul mai grațios.
Cu toate acestea, chiar și fără aceste abilități, puteți reface codul care răspunde la evenimentul ServerClick pentru a
evita erorile potențiale. O abordare bună este utilizarea metodei Decimal.TryParse() în loc de Decimal.Parse(). Spre
deosebire de Parse(), TryParse() nu generează o eroare dacă conversia eșuează - pur și simplu vă informează despre
problemă.
TryParse() acceptă doi parametri. Primul parametru este valoarea pe care doriți să o convertiți (în acest exemplu, S.U.A.
Valoare). Al doilea parametru este un parametru de ieșire care va primi valoarea convertită (în acest caz, variabila numită
USAmount). Ceea ce este special la TryParse() este valoarea returnată booleană, care indică dacă conversia a avut
succes (adevărat) sau nu (fals).
Iată o versiune revizuită a rutinei de tratare a evenimentelor ServerClick care utilizează
TryParse() pentru a verifica dacă există probleme de conversie și pentru a informa utilizatorul:
protejat void Convert_ServerClick(object sender, EventArgs e) { zecimal
USAmount;

Încercați conversia.
bool succes = Decimal.TryParse (US. Value, out USAmount);

Verificați dacă a reușit.

dacă (succes) { // Conversia a reușit.

zecimal euroAmount = USAmount * 0.85M; Result.InnerText =

USAmount.ToString() + " dolari americani = "; Result.InnerText +=
euroAmount.ToString() + " Euro."; } else { // Conversia nu a reușit.

Result.InnerText = "Numărul pe care l-ați tastat nu era în formatul " + "corect.

Utilizați numai numere."; }

}
Tratarea condițiilor de eroare ca acestea este o tehnică esențială într-o pagină web din lumea reală.

Îmbunătățirea convertorului valutar

Acum, că v-ați uitat la controalele de bază ale serverului, s-ar putea părea că beneficiile lor sunt destul de
minore în comparație cu costul învățării unui sistem complet nou de programare web. În secțiunea
următoare, veți începe să extindeți aplicația de conversie valutară. Veți vedea cum puteți "fixa" funcționalități
suplimentare la programul existent într-un mod elegant, modular. Pe măsură ce programul crește, ASP.NET
se ocupă cu ușurință de complexitatea acestuia, îndepărtându-vă de codul încâlcit și complicat care ar fi
necesar în aplicațiile ASP în stil vechi.

144
 CAPITOLUL FUNDAMENTELE
5 FORMULARELOR
WEB

Adăugarea mai multor valute

Prima sarcină este de a permite utilizatorului să aleagă o monedă de destinație. În acest caz, trebuie să utilizați o casetă
listă derulantă. În HTML, o listă verticală este reprezentată de un element <selectare> care conține unul sau mai multe
elemente <opțiune>. Fiecare element <opțiune> corespunde unui element separat din listă.
Pentru a reduce cantitatea de HTML din convertorul valutar, puteți defini o listă verticală fără elemente de listă
adăugând o etichetă goală <selectați> . Atâta timp cât vă asigurați că această etichetă <selectați> este un control al
serverului (oferindu-i un ID și adăugând atributul runat = "server"), veți putea interacționa cu acesta în cod și puteți
adăuga elementele necesare atunci când pagina se încarcă.
Iată codul HTML revizuit pentru pagina de CurrencyConverter.aspx:

<%@ Page language="C#" AutoEventWireup="true"

CodeFile="CurrencyConverter.aspx.cs" mosteniti="CurrencyConverter" %> <html
xmlns="http://www.w3.org/1999/xhtml"> <head> <title>Convertor valutar</title>
</head> <body> <form runat="server"> <div> Convertire: &nbsp; <input type="text"
ID="US" runat="server" /> &nbsp; dolari SUA către &nbsp;

<select ID="Moneda" runat="server" /> <br /><br /> <input type="submit"

value="OK" ID="Convert" OnServerClick ="Convert_ServerClick"
runat="server" /> <br /><br /> <p style="font-weight: bold" ID="Result"
runat="server"></p> </div> </form> </body> </html>

• Notă Până în acest moment, mostrele din această carte au inclus un doctip XHTML. Acum că
sunteți familiarizați cu acest ingredient, nu există niciun motiv să-l repetați. În restul acestei cărți,
doctype-ul este lăsat în afara marcajului paginii web pentru a economisi spațiu. Desigur, îl veți
vedea în continuare dacă descărcați exemplul de cod.

Lista valutară poate fi acum completată folosind codul în timpul rulării. În acest caz, evenimentul ideal este
evenimentul Page.Load, care este declanșat la începutul secvenței de procesare a paginii. Iată codul pe
care trebuie să-l adăugați la clasa paginii CurrencyConverter:
vid protejat Page_Load(Object sender, EventArgs e) { if
(this. IsPostBack == false) { Currency.Items.Add ("Euro");
Currency.Items.Add ("Yen japonez"); } } Currency.Items.Add
("Dolar canadian");
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Disecarea codului . . .
Acest exemplu ilustrează două puncte importante:
• Puteți utiliza proprietatea Elemente pentru a obține elemente într-un control listă. Acest lucru
vă permite să adăugați, să inserați și să eliminați elemente <opțiune> (care reprezintă
elementele din listă). Amintiți-vă, atunci când generați conținut dinamic cu un control de
server, setați proprietățile, iar controlul creează etichetele HTML corespunzătoare.
• Înainte de a adăuga orice elemente la această listă, trebuie să vă asigurați că
aceasta este prima dată când pagina este servită acestui utilizator. În caz contrar,
pagina va adăuga continuu mai multe elemente în listă sau va suprascrie din greșeală
selecția utilizatorului de fiecare dată când utilizatorul interacționează cu pagina. Pentru
a efectua acest test, verificați proprietatea IsPostBack a paginii curente. Cu alte
cuvinte, IsPostback este o proprietate a clasei CurrencyConverter, pe care
CurrencyConverter o moștenește de la clasa generică Page. Dacă IsPostBack este
fals, pagina este creată pentru prima dată și este sigur să o inițializați.

Stocarea informațiilor în listă

Desigur, dacă sunteți un programator HTML veteran, știți că fiecare element dintr-o listă oferă, de asemenea, un
atribut de valoare pe care îl puteți utiliza pentru a stoca o valoare pentru fiecare element din listă. Deoarece
convertorul valutar utilizează o listă scurtă de valute codificate, acesta este un loc ideal pentru a stoca rata de
conversie valutară. Pentru a seta atributul value, trebuie să creați un obiect ListItem pentru fiecare element din listă
și să îl adăugați la controlul HtmlSelect. Clasa ListItem oferă un constructor care vă permite să specificați textul și
valoarea în același timp în care îl creați, permițând astfel un cod condensat ca acesta:

vid protejat Page_Load(Object sender, EventArgs e) { if (this. IsPostBack == false) { // Controlul HtmlSelect acceptă text sau
obiecte ListItem. Currency.Items.Add(nou ListItem("Euro", "0,85")); Currency.Items.Add (nou ListItem("Yen japonez", "110.33")); }
Currency.Items.Add (nou ListItem("Dolari canadieni", "1.2")); }

Pentru a completa exemplul, trebuie să rescrieți codul de calcul pentru a lua în considerare moneda
selectată, după cum urmează:

protejat void Convert_ServerClick(object sender, EventArgs e) { zecimal

oldAmount; bool succes = Decimal.TryParse (US. Value, out
oldAmount);

dacă (succes)

146
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

{ // Regăsiți obiectul ListItem selectat după numărul său de index.

ItemListItem = Currency.Items[Currency.SelectedIndex];

zecimal newAmount = oldAmount * Decimal.Parse(item. valoare);

Result.InnerText = oldAmount.ToString() + " dolari americani = ";
Result.InnerText += newAmount.ToString() + " " + articol. Text;
}
}

Figura 5-5 prezintă convertorul valutar renovat.

Figura 5-5. Convertorul multivalută

Una peste alta, acesta este un bun exemplu al modului în care puteți stoca informații în etichetele HTML
folosind atributul valoare. Cu toate acestea, într-o aplicație mai sofisticată, probabil că nu ați stoca cursul
valutar. În schimb, ați stoca doar un fel de valoare unică de identificare a ID-ului. Apoi, atunci când
utilizatorul trimite pagina, veți prelua rata de conversie corespunzătoare dintr-o bază de date sau din altă
locație de stocare (cum ar fi o memorie cache în memorie).

Adăugarea imaginilor legate

Adăugarea altor funcționalități la convertorul valutar este la fel de ușoară ca adăugarea unui nou buton. De exemplu, ar
putea fi util ca utilitarul să afișeze un grafic al cursului de schimb valutar. Pentru a oferi această caracteristică, programul
ar avea nevoie de un buton suplimentar și de control al imaginii.
Iată codul HTML revizuit:

147
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

<%@ Page language="C#" AutoEventWireup="true"

CodeFile="CurrencyConverter.aspx.cs" mosteniti="CurrencyConverter" %> <html
xmlns="http://www.w3.org/1999/xhtml"> <head> <title>Convertor valutar</title>
</head> <body> <form runat="server"> <div> Convertire: &nbsp; <input type="text"
ID="US" runat="server" /> &nbsp; dolari SUA către &nbsp; <select ID="Moneda"
runat="server" /> <br /><br /> <input type="submit" value="OK" ID="Convert"
OnServerClick ="Convert_ServerClick" runat="server" />

<input type="submit" value="Show Graph" ID="ShowGraph" runat="server" /> <br /><br /> <img ID="Graph"
src="" alt="Currency Graph" runat="server" /> <br /><br /> <p style="font-weight: bold" ID="Result"
runat="server"></p> </div> </form> </body> </html>

După cum este declarat în prezent, imaginea nu se referă la o imagine. Din acest motiv, este logic să o
ascundeți atunci când pagina este încărcată pentru prima dată utilizând acest cod:

vid protejat Page_Load(Object sender, EventArgs e) { if (this. IsPostBack == false) { Currency.Items.Add

(new ListItem("Euro", "0.85")); Currency.Items.Add (nou ListItem("Yen japonez", "110.33"));
Currency.Items.Add (nou ListItem("Dolari canadieni", "1.2"));

} Graph.Visible = false;
}

Interesant este că atunci când un control al serverului este ascuns, ASP.NET omite din pagina HTML
finală. Acum puteți gestiona evenimentul de clic al noului buton pentru a afișa imaginea corespunzătoare.
Convertorul valutar are trei imagini posibile files—pic0.png, pic1.png și pic2.png. Alege unul pe baza
indicelui elementului selectat (deci folosește pic0.png dacă este selectată prima monedă, pic1.png pentru a
doua și așa mai departe). Iată codul care arată diagrama:
vid protejat ShowGraph_ServerClick(Object sender, EventArgs e) { Graph.Src
= "Pic" + Currency.SelectedIndex.ToString() + ".png"; Graph.Visible = true; }

148
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Trebuie să vă asigurați că vă conectați la rutina de tratare a evenimentelor prin buton, deci modificați
elementul <intrare> pentru buton după cum urmează:
<input type="submit" value="Show Graph" ID="ShowGraph"
OnServerClick ="ShowGraph_ServerClick" runat="server" />

De asemenea, va trebui să modificați imaginea graficului atunci când se schimbă moneda, utilizând această
linie de cod în metoda Convert_ServerClick():
Graph.Src = "pic" + currency.SelectedIndex.ToString() + ".png";
Dacă aceasta ar fi o sarcină mai complexă (de exemplu, una care necesită mai multe linii de cod), ar avea sens să o
punem într-o metodă privată separată. Apoi puteți apela această metodă atât din metodele de gestionare a
evenimentelor ShowGraph_ServerClick(), cât și din Convert_ServerClick(), asigurându-vă că nu vă duplicați codul.

Deja convertorul valutar începe să pară mai interesant, așa cum se arată în figura 5-6.

Figura 5-6. Convertorul valutar cu un control al imaginii

149
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Setarea stilurilor
În plus față de un set limitat de proprietăți, fiecare control HTML oferă, de asemenea, acces la atributele CSS
prin colecția sa de stiluri. Pentru a utiliza această colecție, trebuie să specificați numele atributului de stil CSS
și valoarea pe care doriți să o atribuiți. Iată sintaxa de bază:
ControlName.Style["AttributeName"] = "AttributeValue";
De exemplu, puteți utiliza această tehnică pentru a evidenția o intrare nevalidă în convertorul valutar cu culoarea
roșie. În acest caz, va trebui, de asemenea, să resetați culoarea la valoarea inițială pentru o intrare validă,
deoarece controlul utilizează starea de vizualizare pentru a-și aminti toate setările, inclusiv proprietățile stilului:

protejat void Convert_ServerClick(object sender, EventArgs e) { zecimal oldAmount; bool succes = Decimal.TryParse (US. Value,
out oldAmount);

dacă ((oldAmount <= 0) || (succes == fals)) { Result.Style["color"] = "Roșu"; Result.InnerText = "Specificați un număr
pozitiv"; } else { Result.Style["color"] = "Negru";

Regăsiți obiectul ListItem selectat după numărul său de index.

ItemListItem = Currency.Items[Currency.SelectedIndex];

zecimal newAmount = oldAmount * Decimal.Parse(item. valoare);

Result.InnerText = oldAmount.ToString() + " dolari americani = ";
Result.InnerText += newAmount.ToString() + " " + articol. Text;
}
}

Sfat
• Colecția Stil setează atributul stil din eticheta HTML cu o listă de opțiuni de formatare, cum ar fi
familia de fonturi, dimensiunea și culoarea. Veți afla mai multe în capitolul 12. Dar dacă nu sunteți
familiarizați cu stilurile CSS, nu trebuie să le învățați acum. În schimb, puteți utiliza controale web,
care oferă proprietăți de nivel superior care vă permit să configurați aspectul acestora și să creați
automat atributele de stil corespunzătoare. Veți afla despre controalele web în capitolul următor.

Aceasta încheie aplicația simplă de conversie valutară, care se mândrește acum cu calcul automat, imagini
legate și formatare dinamică. În secțiunile următoare, veți analiza mai îndeaproape blocurile de construcție
ale interfețelor ASP.NET.

150
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

O privire mai profundă asupra claselor de control HTML

Clasele asociate din .NET Framework utilizează moștenirea pentru a partaja funcționalitatea. De exemplu,
fiecare control HTML moștenește de la clasa de bază HtmlControl. Clasa HtmlControl oferă caracteristici
esențiale pe care le utilizează fiecare control de server HTML. Figura 5-7 prezintă diagrama moștenirii.

Figura 5-7. Moștenirea controlului HTML

Următoarele câteva secțiuni disecă clasele ASP.NET care sunt utilizate pentru controalele serverului HTML. Puteți utiliza
acest material pentru a ajuta la înțelegerea elementelor comune care sunt partajate de toate controalele HTML. Pentru
detalii specifice despre fiecare control HTML, puteți face referire la referința bibliotecii de clasă în Ajutorul Visual Studio.

Controalele serverului HTML furnizează, în general, proprietăți care se potrivesc îndeaproape atributelor
etichetei. De exemplu, clasa HtmlImage oferă proprietățile Align, Alt, Border, Src, Height și Width. Din acest
motiv, utilizatorii care sunt familiarizați cu sintaxa HTML vor găsi că controalele serverului HTML sunt cele
mai naturale potriviri. Utilizatorii care nu sunt la fel de obișnuiți cu HTML vor găsi probabil că controalele web
(descrise în capitolul următor) au un set mai intuitiv de proprietăți.

Evenimente de control HTML

Controalele serverului HTML oferă, de asemenea, unul dintre cele două evenimente posibile: ServerClick sau
ServerChange. ServerClick este pur și simplu un clic care este procesat pe partea serverului. Este furnizat de
majoritatea comenzilor butoanelor și permite codului să acționeze imediat. De exemplu, luați în considerare controlul

151
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

HtmlAnchor, care este controlul serverului care reprezintă hyperlinkul HTML comun (elementul <a>). Există două moduri
de a utiliza controlul HtmlAnchor. O opțiune este să setați proprietatea HtmlAnchor.HRef la o adresă URL, caz în care
hyperlinkul se va comporta exact ca elementul HTML obișnuit <un> (singura diferență fiind că puteți seta adresa URL
dinamic în codul dvs.). Cealaltă opțiune este să gestionați evenimentul HtmlAnchor.ServerClick. În acest caz, atunci când
se face clic pe link, acesta va posta pagina înapoi, permițând rularea codului. Utilizatorul nu va fi redirecționat către o
pagină nouă decât dacă furnizați un cod suplimentar pentru a redirecționa solicitarea.
Evenimentul ServerChange răspunde atunci când s-a efectuat o modificare la un control text sau selecție. Acest
eveniment nu este atât de util pe cât pare, deoarece nu are loc până când pagina nu este postată înapoi (de exemplu,
după ce utilizatorul face clic pe un buton de trimitere). În acest moment, evenimentul ServerChange apare pentru toate
controalele modificate, urmat de ServerClick corespunzător. Evenimentul Page.Load este primul care se declanșează, dar
nu aveți cum să cunoașteți ordinea evenimentelor pentru alte controale.
Tabelul 5-5 arată ce controale oferă un eveniment ServerClick și care oferă un eveniment ServerChange.

Tabelul 5-5. Evenimente de control HTML

Eveniment Controale care o furnizează

ServerClick HtmlAnchor, HtmlButton, HtmlInputButton, HtmlInputImage, HtmlInputReset

ServerChange HtmlInputText, HtmlInputCheckBox, HtmlInputRadioButton, HtmlInputHidden,

HtmlSelect, HtmlTextArea

Evenimente avansate cu controlul HtmlInputImage

Capitolul 4 a introdus standardul de evenimente .NET, care dictează că fiecare eveniment ar trebui să transmită
exact două informații. Primul parametru identifică obiectul (în acest caz, controlul) care a declanșat evenimentul.
Al doilea parametru este un obiect special care poate include informații suplimentare despre eveniment.

În exemplele pe care le-ați analizat până acum, al doilea parametru (e) a fost întotdeauna folosit pentru a
trece un obiect System.EventArgs gol. Acest obiect nu conține informații suplimentare - este doar un
substituent glorificat. Iată un astfel de exemplu:
protejat void Convert_ServerClick(Object sender, EventArgs e) { ... }

De fapt, un singur control de server HTML trimite informații suplimentare: controlul HtmlInputImage. Acesta
trimite un obiect ImageClickEventArgs (din spațiul de nume System.Web.UI) care furnizează proprietățile X și
Y reprezentând locația în care s-a făcut clic pe imagine. Veți observa că definiția pentru rutina de tratare a
evenimentelor HtmlInputImage.ServerClick este puțin diferită de rutinele de tratare a evenimentelor utilizate
cu alte controale:
protejat void ImgButton_ServerClick(Object sender, ImageClickEventArgs e) { ... }

Folosind aceste informații suplimentare, puteți înlocui mai multe controale de butoane și hărți de imagini cu un singur
control inteligent HtmlInputImage.
Iată marcajul de care aveți nevoie pentru a crea controlul HtmlInputImage pentru acest exemplu:

<input type="image" ID="ImgButton" runat="server" src="button.png"

OnServerClick ="ImgButton_ServerClick" />

152
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Pagina de ImageTest.aspx eșantion prezentată în figura 5-8 pune această caracteristică la lucru cu un
buton grafic simplu. În funcție de faptul dacă utilizatorul face clic pe bordura butonului sau pe suprafața
butonului, se afișează un mesaj diferit.

Figura 5-8. Utilizarea unui control HtmlInputImage

Codul paginii examinează coordonatele clicurilor furnizate de obiectul ImageClickEventArgs și le

afișează într-un alt control. Iată codul paginii de care aveți nevoie:
clasa publică parțială ImageTest : System.Web.UI.Page {

} vid protejat ImgButton_ServerClick(Object sender,

ImageClickEventArgs e) { Result.InnerText = "Ați făcut clic la (" +
e.X.ToString() + ", " + e.Y.ToString() + "). ";

dacă [(e.Y < 100) && (e.Y > 20) && (e.X > 20) &&; (e.X < 275)] {
Result.InnerText += "Ați făcut clic pe suprafața butonului."; } else {
Result.InnerText += "Ați făcut clic pe marginea butonului."; } }

153
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Clasa de bază HtmlControl

Fiecare control HTML moștenește de la clasa de bază HtmlControl. Această relație înseamnă că fiecare
control HTML va accepta un set de bază de proprietăți și caracteristici. Tabelul 5-6 prezintă aceste proprietăți.

Tabelul 5-6. Proprietăți HtmlControl

Proprietate Descriere

Atribute Oferă o colecție a tuturor atributelor setate în eticheta de control și a

Valorile. În loc să citească sau să seteze un atribut prin Atribute, este
Mai bine să utilizați proprietatea corespunzătoare din clasa de control. Cu toate acestea,
Colectarea atributelor este utilă dacă trebuie să adăugați sau să configurați un atribut particularizat
sau un atribut care nu are o proprietate corespunzătoare.

Controale Oferă o colecție a tuturor controalelor conținute în interiorul controlului curent. (Pentru
Exemplu, un control server <div> ar putea conține un control server <intrare>.) Fiecare
obiectul este furnizat ca obiect generic System.Web.UI.Control, astfel încât să puteți
Trebuie să aruncați referința la proprietățile specifice controlului accesului.

Dezactivat Dezactivează controlul atunci când este setat la true, asigurându-se astfel că utilizatorul nu poate
interacționați cu acesta, iar evenimentele sale nu vor fi concediate.

EnableViewState Dezactivează gestionarea automată a stării pentru acest control atunci când este setată la false. În
În acest caz, controlul va fi resetat la proprietățile și formatarea specificate în
eticheta de control de fiecare dată când pagina este postată înapoi. Dacă acest lucru este setat la true (pictograma
implicit), controlul stochează starea sa într-un câmp de introducere ascuns pe pagină, astfel
Asigurați-vă că orice modificări pe care le faceți în cod sunt memorate. (Pentru mai multe
informații, consultați secțiunea "Vizualizare stare" de mai sus din acest capitol.)

Pagină Furnizează o referință la pagina web care conține acest control ca un

System.Web.UI.Page obiect.

Părinte Furnizează o referință la controlul care conține acest control. Dacă controlul este
plasat direct pe pagină (mai degrabă decât în interiorul altui control), acesta va returna un
referință la obiectul paginii.

Stil Oferă o colecție de proprietăți de stil CSS care pot fi utilizate pentru formatare
controlul.

TagName Indică numele elementului HTML subiacent (de exemplu, img sau div).

Vizibil Ascunde controlul când este setat la false și nu va fi redat la codul HTML final
pagina care este trimisă clientului.

Clasa HtmlControl oferă, de asemenea, suport încorporat pentru legarea datelor, pe care îl veți examina
în capitolul 15.

154
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

• Notă Pentru a seta valoarea inițială a unei proprietăți, aveți posibilitatea să configurați controlul
în rutina de tratare a evenimentelor Page.Load sau să ajustați eticheta de control din fișierul .aspx
adăugând atribute. Rețineți că evenimentul Page.Load are loc după inițializarea paginii cu valorile
implicite și setările etichetei. Aceasta înseamnă că codul poate suprascrie proprietățile setate în
etichetă (dar nu invers).

Clasa HtmlContainerControl
Orice control HTML care necesită o etichetă de închidere moștenește de la clasa HtmlContainer (care, la rândul său,
moștenește de la clasa HtmlControl mai de bază). De exemplu, elemente precum <a>, <form> și <div> utilizează
întotdeauna o etichetă de închidere, deoarece pot conține alte elemente HTML. Pe de altă parte, elemente precum
<img> și <input> sunt utilizate numai ca etichete de sine stătătoare. Astfel, clasele HtmlAnchor, HtmlForm și
HtmlGenericControl moștenesc de la HtmlContainerControl, în timp ce HtmlInputImage și HtmlInputButton nu.

Controlul HtmlContainer adaugă două proprietăți la cele definite în HtmlControl, așa cum este descris în
tabelul 5-7.

Tabelul 5-7. HtmlContainerControl Proprietăți

Proprietate Descriere

InnerHtml Conținutul HTML dintre etichetele de deschidere și închidere ale controlului. Caracterele
speciale setate prin această proprietate nu vor fi convertite în entități HTML echivalente.
Aceasta înseamnă că puteți utiliza această proprietate pentru a aplica formatarea cu
etichete imbricate, cum ar fi <b>, <i> și <h1>.

Textul interior Conținutul textului dintre etichetele de deschidere și închidere ale controlului. Caracterele
speciale vor fi convertite automat în entități HTML și afișate ca text (de exemplu, caracterul mai
mic decât (<) va fi convertit în <și vor fi afișate ca < în pagina web). Aceasta înseamnă că nu
puteți utiliza etichete HTML pentru a aplica formatare suplimentară cu această proprietate.
Pagina convertor valutar simplu utilizează proprietatea InnerText pentru a introduce rezultatele
într-un element <p>.

Clasa HtmlInputControl
Clasa HtmlInputControl moștenește de la HtmlControl și adaugă unele proprietăți (prezentate în tabelul 5-8)
care sunt utilizate pentru elementul <intrare>. După cum ați aflat deja, elementul <input> poate reprezenta
controale diferite, în funcție de atributul type. Elementul <input type="text"> este o casetă de text și <input
type="submit"> este un buton.

155
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Tabelul 5-8. HtmlInputControl Proprietăți

Proprietate Descriere

Tip Oferă tipul de control de intrare. De exemplu, un control bazat pe <input type="file"> ar
returna fișierul pentru proprietatea type.

Valoare Returnează conținutul controlului ca șir. În convertorul valutar simplu, această proprietate a
permis codului să preia informațiile introduse în controlul de introducere a textului.

Clasa paginii
Un control pe care nu l-am discutat încă în detaliu este clasa Page. După cum sa explicat în capitolul anterior, fiecare
pagină web este o clasă personalizată care moștenește de la System.Web.UI.Page. Prin moștenirea de la această
clasă, clasa dvs. de pagini web dobândește o serie de proprietăți și metode pe care codul dvs. le poate utiliza. Acestea
includ proprietăți pentru activarea memorării în cache, validării și urmăririi, care sunt discutate pe parcursul acestei cărți.

Tabelul 5-9 oferă o prezentare generală a unora dintre proprietățile fundamentale, pe care le veți folosi
pe parcursul acestei cărți.

Tabelul 5-9. Proprietăți de bază ale paginii

Proprietate Descriere

IsPostBack Această proprietate booleană indică dacă aceasta este prima dată când pagina este
rulată (fals) sau dacă pagina este retrimisă ca răspuns la un eveniment de control, de
obicei cu informații despre starea vizualizării stocate (true). De obicei, veți verifica
această proprietate în rutina de tratare a evenimentelor Page.Load pentru a vă
asigura că inițializarea inițială a paginii web este efectuată o singură dată.

EnableViewState Când este setat la false, acest lucru suprascrie proprietatea EnableViewState a
controalelor conținute, asigurându-se astfel că niciun control nu va păstra informațiile
de stare.
Aplicație Această colecție conține informații care sunt partajate între toți utilizatorii site-ului dvs.
De exemplu, puteți utiliza colecția de aplicații pentru a număra de câte ori a fost
vizitată o pagină. Veți afla mai multe în capitolul 8.

Sesiune Această colecție conține informații pentru un singur utilizator, astfel încât acestea
pot fi utilizate în diferite pagini. De exemplu, puteți utiliza colecția de sesiuni pentru
a stoca articolele în coșul de cumpărături al utilizatorului curent pe un site web de
comerț electronic. Veți afla mai multe în capitolul 8.

Cache Această colecție vă permite să stocați obiecte care necesită mult timp pentru a crea,
astfel încât acestea să poată fi reutilizate în alte pagini sau pentru alți clienți. Această
tehnică, atunci când este implementată corect, poate îmbunătăți performanța
paginilor dvs. Capitolul 23 discută memorarea în cache în detaliu.

156
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Proprietate Descriere

Cerere Aceasta se referă la un obiect HttpRequest care conține informații despre curent
Solicitare web. Puteți utiliza obiectul HttpRequest pentru a obține informații despre
browser-ul utilizatorului, deși probabil veți prefera să lăsați aceste detalii ASP.NET.
Veți utiliza obiectul HttpRequest pentru a transmite informații de la o pagină la
altul cu șirul de interogare din capitolul 8.

Răspuns Aceasta se referă la un obiect HttpResponse care reprezintă răspunsul ASP.NET va

trimiteți la browserul utilizatorului. Veți utiliza obiectul HttpResponse pentru a crea cookie-uri
în capitolul 8 și veți vedea cum vă permite să redirecționați utilizatorul către un alt
pagina web mai târziu în acest capitol.

Server Aceasta se referă la un obiect HttpServerUtility care vă permite să efectuați câteva

sarcini diverse. De exemplu, vă permite să codificați textul, astfel încât să fie sigur
plasați-l într-o adresă URL sau în marcajul HTML al paginii dvs. Veți afla mai multe despre
Aceste caracteristici din acest capitol.

Utilizator Dacă utilizatorul a fost autentificat, această proprietate va fi inițializată cu utilizatorul

informație. Capitolul 19 descrie această proprietate în detaliu.

În secțiunile următoare, veți afla despre două activități care utilizează aceste proprietăți: redirecționarea
utilizatorului către o pagină nouă și codificarea textului care poate conține caractere speciale, astfel încât să
poată fi inserat în HTML pagină web.

Trimiterea utilizatorului la o pagină nouă

În exemplul convertorului valutar, totul a avut loc într-o singură pagină. Într-un site web mai tipic, utilizatorul va trebui
să navigheze de la o pagină la alta pentru a efectua diferite sarcini sau pentru a finaliza o singură operație.

Există mai multe moduri de a transfera un utilizator de la o pagină la alta. Una dintre cele mai simple este
utilizarea unui element obișnuit <un> ancoră, care transformă o porțiune de text într-un hyperlink. În acest
exemplu, cuvântul de aici este un link către o altă pagină:
Faceți clic pe <a href="newpage.aspx">aici</a> pentru a accesa newpage.aspx.
O altă opțiune este de a trimite utilizatorul la o pagină nouă folosind codul. Această abordare este utilă dacă doriți să
utilizați codul pentru a efectua alte lucrări înainte de a redirecționa utilizatorul. De asemenea, este util dacă trebuie să
utilizați codul pentru a decide unde să trimiteți utilizatorul. De exemplu, dacă creați o secvență de pagini pentru plasarea
unei comenzi, puteți trimite clienții existenți direct la casă, în timp ce vizitatorii noi sunt redirecționați către o pagină de
înregistrare.
Pentru a efectua redirecționarea în cod, aveți nevoie mai întâi de un control care determină postarea paginii înapoi. Cu
alte cuvinte, aveți nevoie de un handler de evenimente care să reacționeze la evenimentul ServerClick al unui control,
cum ar fi HtmlInputButton sau HtmlAnchor. Când pagina este postată înapoi și rutina de tratare a evenimentelor
rulează, puteți utiliza metoda HttpResponse.Redirect() pentru a trimite utilizatorul la noua pagină.
Rețineți că puteți obține acces la obiectul HttpResponse curent prin proprietatea Page.Response. Iată
un exemplu care trimite utilizatorul la o altă pagină din același director de site-uri web:
Răspuns.Redirecționare("newpage.aspx");

157
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Când utilizați metoda Redirect(), ASP.NET oprește imediat procesarea paginii și trimite un mesaj de redirecționare
înapoi la browser. Orice cod care apare după apelul Redirect() nu va fi executat. Când browserul primește mesajul de
redirecționare, trimite o solicitare pentru noua pagină.
Puteți utiliza metoda Redirect() pentru a trimite utilizatorul la orice tip de pagină. Puteți chiar să trimiteți utilizatorul
către un alt site web folosind o adresă URL absolută (o adresă URL care începe cu http://), așa cum se arată aici:

Răspuns.Redirecționare("http://www.prosetech.com");
ASP.NET vă oferă o altă opțiune pentru trimiterea utilizatorului la o pagină nouă. Utilizați metoda
HttpServerUtility.Transfer () în loc de Response.Redirect(). Un obiect HttpServerUtility este furnizat prin
proprietatea Page.Server, astfel încât codul de redirecționare ar arăta astfel:
Server.Transfer ("newpage.aspx");
Avantajul utilizării metodei Transfer() este faptul că nu implică browserul. În loc să trimiteți un mesaj de
redirecționare înapoi la browser, ASP.NET începe pur și simplu să proceseze noua pagină ca și cum
utilizatorul ar fi solicitat inițial acea pagină. Acest comportament economisește puțin timp, dar introduce și
unele limitări semnificative. Nu puteți utiliza Transfer() pentru a trimite utilizatorul la un alt site web sau la o
pagină non-ASP.NET (cum ar fi o pagină HTML). Metoda Transfer() vă permite doar să săriți de la o pagină
ASP.NET la alta, în aceeași aplicație web. În plus, atunci când utilizați Transfer(), utilizatorul nu va avea
nicio idee că o altă pagină a preluat, deoarece browserul va afișa în continuare adresa URL originală. Acest
lucru poate cauza o problemă dacă doriți să acceptați marcajele browserului. În ansamblu, este mult mai
frecvent să utilizați HttpResponse.Redirect () decât HttpServerUtility.Transfer ().

Codificare HTML
După cum știți deja, există anumite caractere care au o semnificație specială în HTML. De exemplu, parantezele
unghiulare (< >) sunt utilizate întotdeauna pentru a crea etichete. Acest lucru poate cauza probleme dacă doriți să
utilizați aceste caractere ca parte a conținutului paginii dvs.
De exemplu, imaginați-vă că doriți să afișați acest text pe o pagină web:
Introduceți un cuvânt <aici>
Dacă încercați să scrieți aceste informații pe o pagină sau să le plasați într-un control, ajungeți la
aceasta:
Introduceți un cuvânt
Problema este că browserul a încercat să interpreteze <aici> ca o etichetă HTML. O problemă similară
apare dacă utilizați de fapt etichete HTML valide. De exemplu, luați în considerare acest text:
Pentru text aldin, utilizați eticheta <b>.
Nu numai că textul <b> nu va apărea, dar browserul îl va interpreta ca o instrucțiune pentru a face textul
care urmează îngroșat. Pentru a eluda acest comportament automat, trebuie să convertiți valorile
problematice potențiale în echivalentele lor HTML. De exemplu, <devine <în pagina HTML finală, pe care
browserul o afișează ca caracter <. Tabelul 5-10 enumeră câteva caractere speciale care trebuie
codificate.

158
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Tabelul 5-10. Caractere speciale HTML comune

Rezultat Descriere Entitate codificată

Spațiu nedespărțitor &nbsp;

< Simbol mai mic decât <

> Simbol mai mare decât >

& Ampersand &

" Ghilimele "

Aveți posibilitatea să efectuați această transformare pe cont propriu sau să ocoliți problema utilizând proprietatea
InnerText a unui control server HTML. Când setați conținutul unui control utilizând InnerText, toate caracterele
ilegale sunt convertite automat în echivalentele lor HTML. Cu toate acestea, acest lucru nu vă va ajuta dacă doriți
să setați o etichetă care conține o combinație de etichete HTML încorporate și caractere codificate. De asemenea,
nu va fi util pentru controalele care nu oferă o proprietate InnerText, cum ar fi controlul web Label pe care îl veți
examina în capitolul următor. În aceste cazuri, utilizați metoda HttpServerUtility.HtmlEncode() pentru a înlocui
caracterele speciale. (Rețineți, un obiect HttpServerUtility este furnizat prin proprietatea Page.Server.)
Iată un exemplu:

Va rezulta ca "Introduceți un cuvânt < aici>" în fișierul HTML, dar browserul // îl va

afișa ca "Introduceți un cuvânt <aici>". Ctrl. InnerHtml =
Server.HtmlEncode("Introduceți un cuvânt <aici>");
Sau luați în considerare acest exemplu, care amestecă etichete HTML reale cu text care trebuie codificat:

Ctrl. InnerHtml = "Pentru a <b>bold</b> text folosiți"; Ctrl. InnerHtml

+= Server.HtmlEncode("<b>") + " etichetă.";

Figura 5-9 prezintă rezultatele codificării cu succes și incorect a caracterelor HTML speciale. Puteți consulta
pagina HtmlEncodeTest.aspx inclusă cu exemplele pentru acest capitol.

159
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Figura 5-9. Codificarea caracterelor HTML speciale

Metoda HtmlEncode() este utilă în special dacă regăsiți valori dintr-o bază de date și nu sunteți sigur dacă
textul este HTML valid. Puteți utiliza metoda HtmlDecode() pentru a readuce textul la forma sa normală dacă
trebuie să efectuați operații suplimentare sau comparații cu acesta în codul dvs. Împreună cu metodele
HtmlEncode() și HtmlDecode(), clasa HttpServerUtility include și metodele UrlEncode() și UrlDecode(). La fel
cum HtmlEncode() vă permite să convertiți text în HTML valid fără caractere speciale, UrlEncode() vă permite
să convertiți textul într-o formă care poate fi utilizată într-o adresă URL. Această tehnică este deosebit de utilă
dacă doriți să transmiteți informații de la o pagină la alta prin atașarea acestora la sfârșitul adresei URL. Veți
vedea această tehnică demonstrată în capitolul 8.

Evenimente de aplicare
În acest capitol, ați văzut cum ASP.NET controlează evenimentele de incendiu pe care le puteți gestiona în codul dvs. Deși
controalele serverului sunt cea mai comună sursă de evenimente, există un alt tip de eveniment pe care îl veți întâlni
ocazional: evenimentele aplicației. Evenimentele aplicației nu sunt la fel de importante într-o aplicație ASP.NET ca
evenimentele declanșate de controalele serverului, dar le puteți utiliza pentru a efectua activități suplimentare de
procesare. De exemplu, utilizând evenimentele aplicației, puteți scrie cod de jurnal care rulează de fiecare dată când se
primește o solicitare, indiferent de pagina solicitată. Caracteristicile ASP.NET de bază, cum ar fi starea sesiunii și
autentificarea, utilizează evenimentele aplicației pentru a se conecta la conducta de procesare a ASP.NET.
Nu puteți gestiona evenimentele aplicației în codul din spatele unui formular web. În schimb, aveți nevoie de
ajutorul unui alt ingredient: fișierul global.asax.

160
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Fișierul global.asax
Fișierul global.asax vă permite să scrieți cod care răspunde la evenimentele globale ale aplicației. Aceste evenimente se
declanșează în diferite momente pe durata de viață a unei aplicații web, inclusiv atunci când domeniul aplicației este creat
pentru prima dată (când se primește prima solicitare pentru o pagină din dosarul site-ului dvs. web).
Pentru a adăuga un fișier global.asax la o aplicație din Visual Studio, alegeți Site web Adăugare element nou și
→ selectați tipul de fișier Global Application Class. Apoi, faceți clic pe OK.
Fișierul global.asax arată similar cu un fișier .aspx normal, cu excepția faptului că nu poate conține etichete HTML sau
ASP.NET. În schimb, conține rutine de tratare a evenimentelor care răspund la evenimentele aplicației. Când adăugați
fișierul global.asax, Visual Studio inserează mai multe rutine de tratare a evenimentelor aplicației gata făcute. Pur și
simplu trebuie să completați un cod.
De exemplu, următorul fișier global.asax reacționează la evenimentul EndRequest, care se întâmplă
chiar înainte ca pagina să fie trimisă utilizatorului:

<%@ Application Language="C#" %>

<script language="c#" runat="server"> protected void

Application_EndRequest(expeditor obiect, EventArgs e) { Response.Write("<hr
/>Această pagină a fost servită la " + DateTime.Now.ToString()); } </script>

Această rutină de tratare a evenimentelor utilizează metoda Write() a obiectului Răspuns încorporat pentru a
scrie un subsol în partea de jos a paginii cu data și ora la care a fost creată pagina (consultați Figura 5-10).

Figura 5-10. HelloWorld.aspx cu un subsol automat

Fiecare aplicație ASP.NET poate avea un fișier global.asax. Odată ce îl plasați în directorul corespunzător al

161
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

site-ului web, ASP.NET îl recunoaște și îl folosește automat. De exemplu, dacă adăugați fișierul global.asax
afișat anterior la o aplicație web, fiecare pagină web din acea aplicație va include un subsol.

Notămai
• Cea Această tehnică - răspunsul
bună modalitate la evenimentele
de a adăuga un subsol la aplicației și utilizarea
paginile din metodei
site-ul Web. Response.Write()
O abordare mai - nu este
bună este să adăugați un control de utilizator care creează subsolul (capitolul 11) sau să definiți un
șablon de pagină coordonatoare care include un subsol (capitolul 12).

Evenimente suplimentare de aplicare

Application.EndRequest este doar unul dintre mai mult de o duzină de evenimente la care puteți răspunde în codul
dvs. Pentru a crea un rutină de tratare a evenimentelor diferită, trebuie doar să creați o subrutină cu numele definit.
Tabelul 5-12 listează unele dintre cele mai frecvente evenimente ale aplicației pe care le veți utiliza.

Tabelul 5-12. Evenimente de bază ale aplicației

Metoda de gestionare a evenimentelor Descriere

Application_Start() Apare atunci când aplicația pornește, care este prima dată când primește
o solicitare de la orice utilizator. Nu apare la solicitările ulterioare. Acest
eveniment este utilizat în mod obișnuit pentru a crea sau memora în
cache unele informații inițiale care vor fi reutilizate ulterior.

Application_End() Apare atunci când aplicația se închide, în general, deoarece serverul

web este repornit. Puteți introduce codul de curățare aici.

Application_BeginRequest() Apare cu fiecare solicitare pe care o primește aplicația, chiar înainte de

executarea codului paginii.

Application_EndRequest() Apare cu fiecare solicitare pe care o primește aplicația, imediat după

executarea codului paginii.

Session_Start() Apare ori de câte ori se primește o nouă solicitare de utilizator și se

pornește o sesiune. Sesiunile sunt discutate în detaliu în capitolul 8.

Session_End() Apare atunci când o sesiune expiră sau este încheiată programatic.
Acest eveniment este ridicat numai dacă utilizați stocarea stării sesiunii
în proces (modul InProc, nu modurile StateServer sau SQLServer).

Application_Error() Apare ca răspuns la o eroare netratată. Puteți găsi mai multe

informații despre tratarea erorilor în capitolul 7.

162
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

ASP.NET Configurare
Ultimul subiect pe care îl veți lua în considerare în acest capitol este sistemul de fișiere de configurare ASP.NET.
Fiecare aplicație web include un fișier web.config care configurează setările fundamentale - totul, de la modul în care sunt
afișate mesajele de eroare până la setările de securitate care blochează vizitatorii nedoriți. Veți lua în considerare setările
din fișierul web.config pe parcursul acestei cărți. (Și există mult mai multe setări pe care le nu vor lua în considerare în
această carte, deoarece sunt folosite mult mai rar.)
Fișierele de configurare ASP.NET au câteva avantaje cheie:

Acestea nu sunt niciodată blocate: Puteți actualiza setările web.config în orice moment, chiar și în timp
ce aplicația rulează. Dacă există solicitări în curs de desfășurare, acestea vor continua să utilizeze
setările vechi, în timp ce solicitările noi vor primi imediat setările modificate.
Acestea sunt ușor de accesat și reprodus: Cu condiția să aveți drepturile de rețea corespunzătoare,
puteți modifica un fișier web.config de pe un computer la distanță. De asemenea, aveți posibilitatea să
copiați fișierul web.config și să îl utilizați pentru a aplica setări identice unei alte aplicații sau altui server
web care execută aceeași aplicație într-un scenariu de fermă web.
Setările sunt ușor de editat și de înțeles: setările din fișierul web.config sunt lizibile pentru om, ceea ce
înseamnă că pot fi editate și înțelese fără a fi nevoie de un instrument special de configurare.

În secțiunile următoare, veți obține o prezentare generală la nivel înalt a fișierului web.config și veți
afla cum funcționează sistemul de configurare ASP.NET.

Fișierul web.config
Fișierul web.config utilizează un format XML predefinit. Întregul conținut al fișierului este imbricat într-un element
rădăcină <configurare>. În interiorul acestui element sunt mai multe subsecțiuni, dintre care unele nu le veți
schimba niciodată, iar altele care sunt mai importante.
Iată structura scheletică de bază a fișierului web.config:

<?xml version="1.0" ?> <configuration>

<appSettings>... Setări </app>

<connectionStrings>... </connectionStrings>
<system.web>... </system.web> </configuration>

Rețineți că fișierul web.config este sensibil la litere mari și mici, la fel ca toate documentele XML și începe
fiecare setare cu o literă mică. Aceasta înseamnă că nu puteți scrie <AppSettings> în loc de <appSettings>.

• Sfat Pentru a afla mai multe despre XML, formatul utilizat pentru fișierul web.config,
puteți consulta capitolul 18.

Ca dezvoltator web, există trei secțiuni în fișierul web.config cu care veți lucra. Secțiunea <appSettings> vă
permite să adăugați propriile informații diverse. Veți învăța cum să îl utilizați în secțiunea următoare.
Secțiunea <connectionStrings> vă permite să definiți informațiile de conexiune pentru accesarea unei baze
de date. Veți afla despre această secțiune în capitolul 14. În cele din urmă, secțiunea <system.web> conține
fiecare setare ASP.NET pe care va trebui să o configurați.

163
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

În interiorul elementului <system.web> sunt elemente separate pentru fiecare aspect al configurației
site-ului web. Puteți include cât de puține sau cât de multe dintre acestea doriți. De exemplu, dacă doriți să
controlați modul în care funcționează securitatea ASP.NET, adăugați secțiunile <autentificare> și
<autorizare>. Când creați un site web nou, există un singur element în secțiunea <system.web>, numit
<compilație>:
<?xml version="1.0" ?>
<configuration>
<system.web>
<compilation debug="true" targetFramework="4.0"> </compilation> </ system.web> </configuration>

Elementul <compilare> specifică două setări utilizând două atribute:

depanare: Acest atribut ASP.NET spune dacă să compilați aplicația în modul depanare, astfel încât să
puteți utiliza instrumentele de depanare ale Visual Studio. După cum ați văzut în capitolul 4, Visual
Studio vă întreabă dacă doriți să activați modul de depanare prima dată când rulați o aplicație nouă (și
ar trebui să alegeți întotdeauna da).

Notă Dezavantajul suportului de depanare este că încetinește aplicația atât de ușor și mic
•
Încetinirile se pot adăuga la blocaje mari într-o aplicație web intens traficată în lumea reală. Din
acest motiv, ar trebui să eliminați atributul debug = "true" atunci când sunteți gata să implementați
aplicația pe un server web live.

targetFramework: Acest atribut indică Visual Studio ce versiune de .NET intenționați să utilizați pe
serverul web (ceea ce determină caracteristicile la care veți avea acces în aplicația web). După cum ați
învățat în capitolul 4, setați cadrul țintă atunci când vă creați site-ul web și îl puteți schimba oricând după
aceea.

Veți lua în considerare diferitele elemente pe care le puteți adăuga la secțiunea <system.web> pe
parcursul acestei cărți.

Configurație imbricată
ASP.NET utilizează un sistem de configurare multistrat care vă permite să setați setările la diferite niveluri.
Fiecare server web începe cu câteva setări de bază care sunt definite într-un director, cum ar fi c: \
Windows \ Microsoft.NET \ Framework \ [Version] \ Config. Partea [Versiune] a numelui directorului depinde
de versiunea de .NET pe care ați instalat-o. La momentul scrierii acestui articol, cea mai recentă versiune a
fost v4.0.30319, ceea ce face ca numele complet al folderului c: \ Windows \ Microsoft.NET \ Framework \
4.0.30319 \ Config.

164
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Notă Această cale presupune că utilizați serverul web de testare Visual Studio sau executați IIS web
•
server în modul pe 32 de biți. Dacă executați IIS în modul de 64 de biți, calea se modifică la
c:\Windows\Microsoft.NET\ Framework64\[Version]\Config.

Folderul Config conține două fișiere, denumite machine.config și web.config. În general, nu veți edita manual niciunul
dintre aceste fișiere, deoarece acestea afectează întregul computer. În schimb, veți configura fișierul web.config în
folderul aplicației web. Utilizând acel fișier, aveți posibilitatea să setați setări suplimentare sau să suprascrieți valorile
implicite configurate în cele două fișiere de sistem.
Mai interesant, puteți utiliza setări diferite pentru diferite părți ale aplicației. Pentru a utiliza această tehnică, trebuie să
creați subdirectoare suplimentare în directorul virtual. Aceste subdirectoare pot conține propriile fișiere web.config cu
setări suplimentare.
Subdirectoarele moștenesc setările web.config din directorul părinte. De exemplu, imaginați-vă că creați un
site web în directorul c:\ASP.NET\TestWeb. În interiorul acestui director, creați un folder numit Secure.
Paginile din directorul c:\ASP.NET\TestWeb\Secure pot achiziționa setări din trei fișiere, așa cum se arată
în Figura 5-11.

Figura 5-11. Moștenirea configurației

Orice setări machine.config sau web.config care nu sunt suprascrise în mod explicit în fișierul
c:\ASP.NET\TestWeb\Secure\web.config se vor aplica în continuare paginii SecureHelloWorld.aspx. În acest
fel, subdirectoarele pot specifica doar un set mic de setări care diferă de restul aplicației web. Unul dintre
motivele pentru care poate doriți să utilizați mai multe directoare într-o aplicație este să aplicați setări de
securitate diferite. Fișierele care trebuie securizate vor fi apoi plasate într-un director dedicat cu un fișier
web.config care definește setări de securitate mai stricte.

165
 CAPITOLUL FUNDAMENTELE FORMULARELOR WEB
5

Stocarea setărilor personalizate în fișierul web.config

ASP.NET vă permite, de asemenea, să stocați propriile setări în fișierul web.config, într-un element
numit <appSettings>. Rețineți că elementul <appSettings> este imbricat în elementul rădăcină
<configurare>. Iată structura de bază:
<?xml version="1.0" ?> <configurare>

<appSettings> <!-- Setările personalizate ale aplicației merg aici. --> </appSettings> <system.web> <!-- ASP.NET
Secțiunile de configurare merg aici. --> </system.web> </configuration>

Notă: acest exemplu adaugă un comentariu în locul în care ați găsi în mod normal setări suplimentare. Comentarii XML
•
sunt puse între paranteze cu secvențele de caractere <!-- și -->. De asemenea, puteți utiliza
comentarii XML pentru a dezactiva temporar o setare dintr-un fișier de configurare.

Setările particularizate pe care le adăugați sunt scrise ca variabile șir simple. Este posibil să doriți să
utilizați o setare specială web.config din mai multe motive:

Pentru a centraliza o setare importantă care trebuie utilizată în mai multe pagini diferite: De exemplu,
puteți crea o variabilă care stochează o interogare a bazei de date. Orice pagină care trebuie să
utilizeze această interogare poate apoi să regăsească această valoare și să o utilizeze.
Pentru a facilita comutarea rapidă între diferite moduri de funcționare: De exemplu, puteți crea o
variabilă specială de depanare. Paginile dvs. web ar putea verifica această variabilă și, dacă este
setată la o valoare specificată, să emită informații suplimentare pentru a vă ajuta să testați aplicația.
Pentru a seta unele valori inițiale: În funcție de operație, utilizatorul poate modifica aceste valori,
dar fișierul web.config ar putea furniza valorile implicite.

Puteți introduce setări personalizate utilizând un element <add> care identifică un nume unic al variabilei
(cheie) și conținutul variabilei (valoare). Următorul exemplu adaugă o variabilă care definește o cale de fișier
în care sunt stocate informații importante:
<Setări aplicație>
<add key="DataFilePath" value="e:\NetworkShare\Documents\WebApp\Shared" />
Setări </app>

Puteți adăuga câte setări de aplicație doriți, deși acest exemplu definește doar una. Puteți crea o pagină de
test simplă pentru a interoga aceste informații și pentru a afișa rezultatele, așa cum se arată în exemplul
următor (care este furnizat cu exemplul de cod ca ShowSettings.aspx și ShowSettings.aspx.cs). Regăsiți
setările aplicației particularizate de la web.config după numele cheii, utilizând

166