RAZVOJ SPLETNIH APLIKACIJ Z ASP.NET 2.0, …UDK: 004.738.52:004.439(043.2) Abstract The diploma work introduces the description of a web application development tool ASP.NET, version

UNIVERZA V MARIBORU

FAKULTETA ZA ELEKTROTEHNIKO,

RAČUNALNIŠTVO IN INFORMATIKO

Mitja Capuder

RAZVOJ SPLETNIH APLIKACIJ Z ASP.NET 2.0,

ATLAS IN XAML

Diplomska naloga

Maribor, maj 2008

I

UNIVERZA V MARIBORU

FAKULTETA ZA ELEKTROTEHNIKO, RAČUNALNIŠTVO IN INFORMATIKO 2000 Maribor, Smetanova ul. 17

Diplomska naloga visokošolskega študijskega programa

RAZVOJ SPLETNIH APLIKACIJ Z ASP.NET 2.0, ATLAS IN XAML

Študent: Mitja Capuder

Študijski program: visokošolski, Računalništvo in informatika

Smer: Informatika

Mentor: izr. prof. dr. Matjaž B. Jurič

Maribor, maj 2008

II

SKLEP O DIPLOMSKI NALOGI

III

Zahvala

Zahvaljujem se mentorju dr. Matjažu B. Juriču in

mag. Andreju Bregarju za pomoč in vodenje pri

opravljanju diplomskega dela.

Posebna zahvala velja vsem bližnjim za podporo in

vzpodbudo.

IV

RAZVOJ SPLETNIH APLIKACIJ Z ASP.NET 2.0,

ATLAS IN XAML

Ključne besede: ASP.NET 2.0, ATLAS, XAML, ogrodje, označevalni jezik. UDK: 004.738.52:004.439(043.2) Povzetek

V diplomskem delu smo opisali ogrodje za razvoj spletnih aplikacij ASP.NET verzije 2.0.

Opisali smo novo spletno tehnologijo, ki vključuje knjižnice odjemalčevih skript z razvijalskim

ogrodjem ASP.NET 2.0., pa tudi novo razvojno infrastrukturo, gradnike in vse ostale novosti v

tehnologiji ASP.NET 2.0. Prav tako smo opisali spletno tehnologijo ATLAS ASP.NET, njene

značilnosti ter gradnike. Predstavili smo tudi novosti v tehnologiji ASP.NET 3.5, med drugim

označevalni jezik XAML, ki ga uporabljamo za razvoj uporabniškega vmesnika in ki je namenjen

za hitro gradnjo uporabniškega vmesnika, pri katerem ločimo aplikacijsko logiko od

predstavitvene plasti. Opisali smo lastnosti XAML jezika in njegove gradnike.

V praktičnem delu diplomske naloge smo razvili spletno aplikacijo za upravljanje s projekti,

kjer smo predstavili nekaj novosti v ASP.NET 2.0, Atlas ter v jeziku XAML.

V

WEB APPLICATION DEVELOPMENT WITH

ASP.NET 2.O, ATLAS AND XAML

Keywords: ASP.NET 2.0, ATLAS, XAML, framework, markup language.

UDK: 004.738.52:004.439(043.2)

Abstract

The diploma work introduces the description of a web application development tool

ASP.NET, version 2.0. A new web technology that includes the ASP.NET 2.0 development

framework for client-script libraries is described, but also a new development infrastructure,

widgets and all other innovations in ASP.NET 2.O technology. It describes the ATLAS ASP.NET

web technology, as well as its features and widgets. It introduces the innovations in ASP.NET

3.5, inter alia the XAML markup language that is used for designing user interfaces and destined

for rapid user interface building where the application logic is separated from the demo layer.

In the practical part of the diploma work a web project-managing application in which we

introduced some innovations of ASP.NET 2.0, Atlas and XAML language, was developed.

VI

VSEBINA

1. UVOD ..................................................................................................................................... 1

2. PREGLED ASP.NET 2.0 ............................................................................................................ 2

2.1 Zgodovina ...................................................................................................................................... 2

2.2 Novosti ASP.NET 2.0 ...................................................................................................................... 4

2.2.1 Nova razvojna infrastruktura ................................................................................................ 4

2.2.2 Članstvo in upravljanje z vlogami .......................................................................................... 4

2.2.3 Personalizacija ....................................................................................................................... 5

2.2.4 Nov sistem prevajanja ........................................................................................................... 5

2.2.5 Predloga strani ...................................................................................................................... 6

2.2.6 Teme ..................................................................................................................................... 7

2.2.7 Novi objekti za dostop do podatkov ..................................................................................... 8

2.2.8 Novi spletni gradniki ............................................................................................................. 8

2.2.9 Novo intergrirano razvojno okolje za ustvarjanje ASP.NET 2.0 strani ................................ 10

3. Analiza ASP.NET 2.0 ............................................................................................................. 11

3.1 Spletni gradnik BulletedList ........................................................................................................ 11

3.2 Spletni gradnik HiddenField ........................................................................................................ 12

3.3 Spletni gradnik FileUpload .......................................................................................................... 13

3.4 Spletni gradnik MultiView in View .............................................................................................. 14

3.5 Spletni gradnik Wizard ................................................................................................................ 15

3.6 Spletni gradnik ImageMap ......................................................................................................... 17

3.7 Delo s predlogami strani ............................................................................................................. 19

3.8 Teme in preobleke ...................................................................................................................... 22

3.9 Dostop do podatkov v ASP.NET 2.0 ............................................................................................ 25

3.9.1 Kaj je novega pri dostopu do podatkov .............................................................................. 25

3.9.2 Podatkovni gradniki ............................................................................................................ 25

3.10 Uporaba gradnikov Bound List skupaj s podatkovnimi gradniki ................................................. 31

3.10.1 GridView .............................................................................................................................. 32

3.10.2 DetailsView ......................................................................................................................... 35

3.10.3 FormView ............................................................................................................................ 36

VII

3.10.4 Drugi s podatki povezani gradniki ....................................................................................... 36

3.11 Upravljanje s podatki z uporabo ADO.NET ................................................................................. 37

3.11.1 Osnovni ADO.NET imenski prostori in kategorije ............................................................... 37

3.11.2 Uporaba objekta Connection .............................................................................................. 38

3.11.3 Na novo dodane posebnosti ADO.NET ............................................................................... 39

3.12 Navigacija spletišča ..................................................................................................................... 41

3.12.1 Kazalo spletišča na osnovi XML ........................................................................................... 42

3.12.2 Spletni gradnik SiteMapPath ............................................................................................... 44

3.12.3 Spletni gradnik Menu .......................................................................................................... 45

3.12.4 Shema navigacije strani ...................................................................................................... 45

3.13 Članstvo v ASP.NET 2.0 ............................................................................................................... 46

3.13.1 ASP.NET 2.0 avtentikacija ................................................................................................... 46

3.13.2 ASP.NET 2.0 avtorizacija ...................................................................................................... 48

3.14 Spletni gradniki (WebParts) ........................................................................................................ 48

3.14.1 Gradniki za delo s spletnimi gradniki .................................................................................. 49

3.15 Predpomnjenje............................................................................................................................ 50

3.16 Ostale novosti ............................................................................................................................. 51

3.17 Novosti v ASP.NET 3.5 ................................................................................................................. 51

3.18 Novosti v Visual Studio 2008 ....................................................................................................... 53

4. ASP.NET 2.0 in ATLAS........................................................................................................... 55

4.1 Kaj je Atlas ................................................................................................................................... 55

4.2 Kaj nudi Atlas? ............................................................................................................................. 56

4.3 Spletni gradniki ASP.NET Atlas .................................................................................................... 57

4.4 Ogrodje Atlas-Ajax ...................................................................................................................... 59

4.5 Tehnični koncepti AJAX ............................................................................................................... 60

5. XAML.................................................................................................................................... 61

5.1 Kaj je XAML?................................................................................................................................ 61

5.2 XAML in objekti ........................................................................................................................... 61

5.3 Lastnosti XAML ............................................................................................................................ 62

5.4 Razvoj XAML aplikacij .................................................................................................................. 65

5.4.1 Nadzorni elementi ............................................................................................................... 68

5.4.2 Ploščni elementi .................................................................................................................. 69

VIII

5.4.3 Razporeditev in postavitev.................................................................................................. 69

6. Razvoj z ASP.NET 2.0............................................................................................................ 71

6.1 Zgradba aplikacije ....................................................................................................................... 72

6.1.1 Razvoj uporabniškega vmesnika z jezikom XAML ............................................................... 77

6.2 Uporaba gradnikov jezika XAML v projektu ................................................................................ 78

7. SKLEP ................................................................................................................................... 81

8. LITERATURA ......................................................................................................................... 82

IX

UPORABLJENE KRATICE

ASP – Active Server Pages

HTML – HyperText Markup Language

HTTP – HyperText Transfer Protocol

VB – Visual Basic

JS – JavaScript

API – Application Pogramming Interface

SQL – Structured Query Language

IDE – Integrated Development Environment

GUID – Globally Unique Identifier

ADO – Access Database Object

DTS – Data Transformed Source

BCP – BulkCopy Program

MDA – System Engineering

DOM – Document Object Model

XAML – Extensible Application Markup Language

XML – Extensible Markup Language

SQL - Structured Query Language

UVOD 1

1. UVOD

Razvoj spletnih aplikacij se iz dneva v dan razvija, postaja vse preprostejši. Za uspešen

razvoj spletnih aplikacij je potreben sodobni razvojni proces. Še preden so se razvile spletne

aplikacije, se je večina razvijalcev osredotočila na razvoj namiznih aplikacij. Industrija pa je

postajala vse bolj zahtevna, in tako so se s prihodom interneta pojavile spletne aplikacije, ki

so bile dostopne vsem, ki so imeli dostop do interneta ter so s tem nakazale smernice

prihodnosti. Da pa bi Microsoft lahko sodeloval v spletnem svetu, je razvil skriptni jezik

ASP.

Z ASP je bil razvoj spletnih aplikacij dokaj hiter in lahek. Razvijalec je spletno stran

razvijal z oznakami HTML, dinamične elemente pa je definiral s skriptnim jezikom, kot sta

JavaScript ter VisualBasic. ASP se je posodabljal in izšle so nove verzije (več o tem je

opisano v poglavju 2, kjer je predstavljen zgodovinski razvoj).

Z razvojem ASP.NET se je močno poenostavilo programiranje spletnih aplikacij

predvsem z novimi spletnimi gradniki, hkrati pa se je povečala produktivnost pri izdelavi

spletnih aplikacij (več o analizi gradnikov v poglavju 3).

ASP.NET ATLAS je spletna tehnologija, ki temelji na odjemalčevih skriptah. Z

ASP.NET 2.O pa nudi enake razvijalske platforme ter nam omogoča prevzem tehnik AJAX

(več o tej tehnologiji je zapisano v poglavju 4).

Da pa bi Microsoft zagotovil hiter razvoj uporabniškega vmesnika za aplikacije .NET, je

razvil nov označevalni jezik XAML. XAML dopušča razvijalcu popoln nadzor nad grafiko

vmesnika. Z uporabo XAML so tako aplikacije robustnejše ter se zlahka nadgrajujejo in

spreminjajo. Jezik XAML je podrobneje opisan v poglavju 5.

PREGLED ASP.NET 2.0 2

2. PREGLED ASP.NET 2.0

Razvoj ASP.NET se nadaljuje. Osnovni cilj ASP.NET 2.0 je omogočiti ustvarjanje

zmogljivih, varnih in dinamičnih aplikacij ob pisanju čim manj kode.

2.1 Zgodovina

Še preden so organizacije sploh razmišljale o razvoju aplikacij za internet, se je razvoj

programske opreme osredotočal predvsem na namizne aplikacije. Te aplikacije so se

uporabljale za vse, od domačega računanja in igranja pa do dela v pisarnah. V tem času je

Microsoft svoje namizne aplikacije razvijal tudi z uporabo VisualBasic. Visual Basic ni bil

le programski jezik, bil je povezan z IDE, ki je omogočal lažji razvoj namiznih aplikacij. Pri

modelu VisualBasic so razvijalci lahko gradnike spustili na delovni prostor, zanje določili

lastnosti in za njimi podali kodo, da so upravljali dogodke gradnikov.

Sredi 90-tih se je pojavil internet. Toda modela VisualBasic Microsoft ni mogel

prenesti na razvoj aplikacij za internet. Internet je imel vsekakor veliko moč in težave z

modelom namiznih aplikacij na osnovi lahkih odjemalcev so se takoj pokazale. Aplikacije za

internet so predstavljale edinstven primerek aplikacije, dostopne vsem. Imeti en primerek

aplikacije je pomenilo, da so bile spremembe, ki so bile narejene pri nadgradnji ali

popravkih, takoj na voljo vsakemu uporabniku, ki je aplikacijo obiskal preko brskalnika. Da

bi sodeloval v svetu internetnih aplikacij, je Microsoft razvil tahnologijo Active Server

Pages (ASP). ASP je bil hiter in lahek način razvijanja internetnih aplikacij. ASP stran je

sestavljala mešanica značk in programskih skript. Moč ASP-ja je bila v tem, da je bilo na

stran, ki se je izvajala na spletnem strežniku, kodna navodila VBScript ali JScript možno

vključiti, še preden je bila stran končno poslana spletnemu brskalniku končnega uporabnika.

To je bil lahek način ustvarjanja dinamičnih spletnih strani po meri na osnovi parametrov, ki

jih je določal razvijalec.

ASP je za nadzorovanje »obnašanja« strežnika uporabljal skripto med oklepaji in

znake za odstotke (<% %>). Razvijalec je potem lahko ustvaril ASP stran tako, da je začel z

nizom oznak HTML. Vsak dinamični element, potreben za stran, je bil definiran z uporabo


skriptnega jezika (kot sta npr. VBScript ali JScript). Ko je uporabnik z uporabo brskalnika

od strežnika zahteval stran, je asp.dll (knjižnica, ki je povezovala skriptni jezik in spletni

strežnik) prevzel nadzor nad stranjo in avtomatično definiral vse dinamične aspekte strani na

osnovi programske logike, določene v skripti. Ko so bili vsi dinamični aspekti strani

definirani, so bili rezultat HTML strani zadetki, posredovani brskalniku stranke, ki jih je

zahtevala.

ASP se je razvijal in izšle so nove verzije. Tako sta bila priljubljena ASP 2.0 in 3.0,

ker je tehnologija omogočila relativno enostavno in lahko ustvarjanje spletnih strani. Njuna

priljubljenost se je še povečevala, ker sta se pojavila v poznih devetdesetih, ko se je obdobje

»pikacom« ravno začelo. V tem času se je razvilo cel kup novih spletnih strani in portalov,

in ASP je bil ena vodilnih tehnologij, s katero so jih posamezniki in podjetja ustvarjali. Celo

dandanes na internetu še zmeraj najdemo veliko ASP strani – celo nekatere spletne strani

samega Microsofta.

A celo v času zadnje izdaje Active Service Pages leta 1998 sta Microsoftova

uslužbenca Marc Anders in Scott Guthrie imela druge ideje. Le-te so dale tako imenovan

XSP (kratica brez pomena): nov način ustvarjanja spletnih aplikacij – objektno, namesto

proceduralno orientiranih kot pri ASP 3.0. Svojo idejo sta pokazala različnim skupinam v

Microsoftu in bila dobro sprejeta. Poleti leta 2000 je bila na Microsoft's Professionnal

Developers Conference izdana nedokončana verzija takratnega ASP+. Udeleženci so začeli

vneto delati z njim. Ko je bila tehnologija na voljo (s končno izdajo .NET Framework 1.0),

so jo preimenovali v ASP.NET – dobila je končnico .NET, ki jo je v tistem času dobivala

večina Microsoftovih novih izdelkov [2].

Pred uvedbo .NET sta bila model, ki ga je zagotovil klasični ASP, in to, kar se je

razvilo v Visual Basicu, tako različna, da je nekaj razvijalcev VB razvilo tudi spletne

aplikacije – in nekaj razvijalcev spletnih aplikacij je razvilo aplikacije tudi na osnovi lahkih

odjemalcev.

Razlike so bile velike. ASP.NET je to vrzel premostil in k razvoju programskih strani

doprinesel dogodkovni model v slogu Visual Basic in s tem zagotovil prepotrebne tehnike

upravljanja stanja HTML.

Ta model je precej podoben zgodnejšemu modelu Visual Basic, v katerem razvijalec

lahko povleče in izpusti gradnik na oblikovno površino ali delovni prostor, nadzoruje


lastnosti gradnika in celo dela s kodo v ozadju teh gradnikov, da vpliva na nekatere dogodke,

ki se zgodijo v ciklu njihovega delovanja. To, kar je ustvaril ASP.NET, je res najboljša

kombinacija obeh modelov.

2.2 Novosti v ASP.NET 2.0

2.2.1 Nova razvojna infrastruktura

Vznemirljiv napredek ASP.NET 2.0 je v tem, da je nova infrastruktura prisotna v

vsaki aplikaciji. Ekipa ASP.NET je izbrala nekaj najbolj splošnih programskih operacij, ki se

izvajajo z ASP.NET 1.0, in jih vgradila neposredno v ASP.NET. To prihrani kar nekaj časa

pri pisanju kode.

2.2.2 Članstvo in upravljanje z vlogami

Pri razvijanju portala, ki je za privilegiran dostop od uporabnikov zahteval prijavo v

aplikacijo, je bilo le-tega potrebno ustvariti lastnoročno. Ustvarjanje aplikacij s področji, ki

so dostopna le izbranim posameznikom, je lahko zapleteno. Pri ASP.NET 2.0 pa je ta

možnost že vgrajena. Zdaj lahko preverimo skladnost uporabnikov z zahtevami, kot je

prikazano v primeru 2.1 [1].

VB

If (Membership.ValidateUser (Username.Text, Password.Text)) Then

‘ dovoli dostop tukaj

End If

C#

if (Membership.ValidateUser (Username.Text, Password.Text)) {}

// koda dostopa

Primer 2.1: Skladnost uporabnika

Nova verzija API in gradnikov v ASP.NET 2.0 omogoča nadzorovanje upravljanja

članstva in vlog uporabnikov. Z uporabo API zlahka upravljamo z uporabniki in njihovimi


kompleksnimi vlogami: lahko jih ustvarimo, brišemo ter urejamo. Te zmogljivosti dobimo z

uporabo API ali vgrajenega spletnega orodja, imenovanega Web Site Administration Tool.

Za shranjevanje uporabnikov in njihovih vlog ASP.NET uporablja datoteko .mdb (vrsta

datoteke za nov SQL Server Express Edition, katere ne smemo zamenjevati z Microsoft

Access). Toda nikakor nismo omejeni samo na shranjevanje teh podatkov. Vse, kar nam

ponuja ASP.NET, lahko razširimo, ustvarimo lastne ponudnike ter za shrambo podatkov

uporabimo, karkoli želimo. Lahko ustvarjamo svojo uporabniško shrambo v LDAP-u ali v

podatkovni bazi Oracle.

2.2.3 Personalizacija

Napredna lastnost, ki jo portali zelo radi ponudijo članom, je možnost personalizacije

njihove ponudbe, tako da lahko stran izgleda in funkcionira, kakorkoli končni uporabnik

želi. Možnost personalizacije aplikacije in shranjevanje nastavitev personalizacije je zdaj

popolnoma vgrajena v ogrodje ASP.NET. Na voljo je tudi nekaj možnosti za shranjevanje že

ustvarjenih nastavitev personalizacije. Možnost shranjevanja teh nastavitev v Microsoft

Access ali v SQL Server je vgrajena v ASP.NET 2.0. Uporabimo lahko model fleksibilnega

ponudnika za možnost članstva in vlog API in potem spremenimo način, kako vgrajen

ponudnik uporablja razpoložljivo shrambo podatkov, ali pa ustvarimo svojega ponudnika po

meri, da delamo s popolnoma novo shrambo podatkov.

Personalizacija aplikacijskih programskih vmesnikov podpira tudi združitev shramb

podatkov, kar pomeni, da lahko hkrati uporabljamo več shramb podatkov.

Ker je z uporabo novih API ustvarjanje spletišča za prikrojevanje tako preprosto, je ta

lastnost precejšnja pridobitev za vsako aplikacijo, ki jo ustvarimo.

2.2.4 Nov sistem prevajanja

Pri ASP.NET 2.0 je koda sestavljena in prevedena na nov način. Pri ASP.NET 1.0 je

bilo prevajanje zmeraj težavno. Pri ASP.NET 1.0 je bilo z uporabo ASP.NET in Visual


Studio možno ustvariti aplikacijske datoteke s kodo v ozadju, jih razvrstiti, potem pa smo

lahko samo opazovali, kako so se datoteke s končnico »aspx« glede na zahteve prevajale

stran po stran. Če smo pri ASP.NET 1.0 v datoteki s kodo v ozadju kaj spremenili, se to na

aplikaciji ni odražalo, vse dokler ni bila preoblikovana celotna aplikacija. To je pomenilo, da

je bilo treba pred ponovnim prevajanjem strani še enkrat predelati isto zahtevo stran za

stranjo. ASP.NET 2.0 ponuja nov model kode v ozadju, saj .NET Framework 2.0 ponuja

možnost dela z delnimi razredi (imenovanimi tudi delni tipi) [3].

Aplikacije ASP.NET 2.0 lahko vključujejo direktorij \App_Code, kamor postavimo

izvorno kodo razreda. Vsak razred, ki ga tja postavimo, je dinamično kompiliran in se odraža

na aplikaciji. Če kaj spremenimo, ni potreben ločen proces ustvarjanja kot pri ASP.NET 1.0.

Kot pri klasičnem ASP 3.0 gre za model razvrščanja »samo shrani in išči«.

Visual Studio Web Developer za vsak objekt samodejno uporabi tudi samodopolnjevanje, ki

ga postavimo v direktorij \App_Code, pa najsi delamo z modelom izvorne kode v ozadju ali

pa programiramo medvrstično.

Aplikacije ASP.NET 2.0 prevajamo tako, da po razvrstitvi v aplikacijski koren naše

aplikacije samo prikličemo imaginarno datoteko precompile.axd. En sam priklic povzroči, da

se prevede celotna aplikacija. Če so kje v aplikaciji najdene napake, prejmemo obvestilo o

napaki. Možno je tudi prevajanje aplikacije in dostava samo ustvarjenega zbirnika.

2.2.5 Predloga strani

Z uvedbo predlog strani v ASP.NET 2.0 zdaj lahko v svojih ASP.NET aplikacijah

uporabljamo vizualno nasleditev. Ker imajo ASP.NET aplikacije skozi vse strani podobno

strukturo, se zdi smiselno, da ustvarimo šablono strani in skozi vso aplikacijo uporabljamo to

isto šablono. V ASP.NET 2.0 to storimo tako, da ustvarimo glavno stran, ki ima končnico

»master«, kot je prikazano na sliki 2.1.


Slika 2.1: Predloga strani

2.2.6 Teme

Uvedba tem v ASP.NET 2.0 je omogočila konsistenten izgled in vzdušje skozi

celotno spletišče. Teme so preproste tekstovne datoteke, v katerih definiramo izgled spletnih

gradnikov, ki jih lahko uporabljamo po vsem spletišču, na posamezni strani ali v določenem

spletnem gradniku. Poleg definicij spletnih strežnikov zlahka vključimo tudi grafiko in stilne

predloge [1].

Teme za uporabo v določeni aplikaciji se shranijo v direktorij \App_Theme v

korenskem direktoriju. Imenitna možnost pri temah je, da jih lahko dinamično uporabimo

glede na nastavitve nove storitve personalizacije, ki jo omogoča ASP.NET 2.0. Vsak

posamezni uporabnik portala ali aplikacije ima lahko svoj lasten izgled po meri in vzdušje,

ki ga je izbral iz naše ponudbe.


2.2.7 Novi objekti za dostop do podatkov

Ena bolj zahtevnih nalog kodiranja v ASP.NET 1.0 je bil dostop do podatkov.

Velikokrat je to pomenilo delo s številnimi objekti. Proces prikazovanja podatkov iz

Microsoft SQL Server tabele v spletnem gradniku DataGrid je bil zapleten. Tako smo na

primer morali najprej ustvariti številne nove objekte. Ti so vključevali objekt

SQLConnection, ki mu je sledil objekt SQLCommand. Ko so bili ti objekti na mestu, smo s

povezovanjem rezultata z DataGrid ustvarili SQlDataReader, da smo napolnili DataGrid. Na

koncu se je pojavila tabela, ki je vsebovala vsebino podatkov, ki smo jih priklicovali. Z

uvedbo novega niza objektov, ki delajo posebej z dostopom do podatkov in njihovim

priklicem, ASP.NET 2.0 ta temeljit postopek ukinja. Novi podatkovni gradniki so za

uporabo tako preprosti, da nam za dostop do podatkov, s katerimi potem napolnimo

ASP.NET spletne gradnike, in njihov priklic, ni treba napisati nobene kode.

Najboljše pri teh novih funkcijah pa je, da niso omejene le na Microsoft SQL Server.

Pravzaprav nam je na voljo več podatkovnih spletnih gradnikov. Ustvarimo lahko tudi svoje

lastne. Poleg spletnega gradnika SQLDataSource je ASP.NET 2.0 uvedel še spletne gradnike

AccessDataSource, XmlDataSource, ObjectDataSource in SiteMapDataSource.

2.2.8 Novi spletni gradniki

Doslej smo videli številne spletne gradnike, ki jih lahko uporabimo pri ustvarjanju

aktivnih strežniških strani s tehnologijo ASP.NET 2.0.

Poleg gradnikov, doslej predstavljenih v tem poglavju, ASP.NET 2.0 ponuja več kot

50 dodatnih spletnih gradnikov. Pravzaprav je bilo uvedenih toliko novih spletnih gradnikov,

da je bilo treba pri naslednjem IDE za ustvarjanje ASP.NET aplikacij, Visual Studio 2005,

preurediti Orodjarno, kamor se shranjujejo vsi spletni gradniki. Namesto, da bi bili prikazani

neposredno v seznamih, kot so bili pri Visual Studio. NET ali pri ASP.NET Web Matrix, so

zdaj razdeljeni na kategorije. Nova Orodjarna Visual Studio 2005 je prikazana na sliki 2.2

[4].


Slika 2.2: Orodjarna


2.2.9 Novo intergrirano razvojno okolje za ustvarjanje ASP.NET 2.0 strani

Svojo ASP.NET aplikacijo lahko pri ASP.NET 1.0/1.1 ustvarimo z uporabo Notepad

Visual Studio.NET 2002 in 2003, pa tudi z za hobi naravnanim ASP.NET Web Matrix. V

družino Visual Studio ASP.NET prihaja z drugim IDE – Visual Studio 2005 [6].

Visual Studio 2005 ponuja nekaj dramatičnih izboljšav, ki so povsem spremenile način

ustvarjanja ASP.NET aplikacij. Najbolj vznemirljiva sprememba pri IDE je, da Visual

Studio 2005 ustvarja aplikacije na podlagi sistema datotek in ne sistema projektov, ki jih je

uporabljal Visual Studio.NET. Pri uporabi Visual Studio.NET je bilo treba ustvarjati nove

projekte (npr. ASP.NET Web Application Project). Pri tem procesu je bilo v aplikaciji

ustvarjenih več projektnih datotek. Ker pa je bilo vse zasnovano na enem projektu, je postalo

razvijanje aplikacij v timskem okolju zelo težko.

Spletni projekti v Visual Studiu 2005 pa temeljijo na pristopu sistema datotek. V vaš

projekt ni vključenih nobenih projektnih datotek, to pa omogoča, da na isti aplikaciji zlahka

dela več razvijalcev, ne da bi si bili napoti. Druge spremembe se tičejo prevajalnega sistema.

Zdaj lahko ASP.NET strani ustvarjamo s pomočjo novega modela kode v ozadju [7].

Analiza ASP.NET 2.0 11

3. Analiza ASP.NET 2.0

Bistvena infrastruktura je bila že v ASP.NET 1.0/1.1 zadovoljiva, a z zelo izboljšano

izdajo 2.0 je ekipa ASP.NET razvijalcem še bolj olajšala življenje.

Namen velike zbirke novih gradnikov je večja produktivnost. Ti gradniki zagotavljajo

napredno funkcionalnost, ki bi jo v preteklosti morali s trdim delom sprogramirati ali pa

preprosto opustiti. V klasičnih ASP časih se je npr. na internetnih spletnih mestih uporabljalo

le nekaj koledarjev. Z uvedbo spletnega gradnika Calendar v ASP.NET 1.0 je ustvarjanje

koledarja v spletišču postalo vsakdanje opravilo. Tudi ustvarjanje aktivne slike na vrhu slike

je bilo še eno težko dosegljivo opravilo v ASP.NET 1.x. Z uporabo novega spletnega

gradnika pa je ta možnost zdaj vgrajena v ASP.NET 2.0.

To poglavje obravnava nekatere od teh novih spletnih gradnikov in pojasnjuje njihovo

uporabo v ASP.NET 2.0 aplikacijah. Ne pokriva pa vseh novih gradnikov [1].

3.1 Spletni gradnik BulletedList

Pogost element HTML spletne strani je zbiranje podatkov v seznamu alinej. Spletni

gradnik BulletedList je namenjen preprostemu prikazu seznama predmetov z alinejami na

urejen (z uporabo HTML elementa <ol>) ali neurejen ( z uporabo HTML elementa <ul>)

način. Poleg tega lahko z gradnikom določimo tudi slog, ki ga uporabimo za prikaz seznama.

Gradnik BulletedList je lahko sestavljen iz poljubnega števila gradnikov <asp:ListItem>,

lahko pa ga povežemo z nekim podatkovnim virom in ga na podlagi priklicane vsebine

napolnimo.

Gradnik BulletedList ima atribut, imenovan DisplayMode, ki ima tri možne vrednosti:

Text, HyperLink, and LinkButton. Uporaba vrednosti Text pomeni, da so predmeti v

seznamu alinej prikazani samo kot tekst. Vrednost HyperLink pomeni, da je vsak od

predmetov pretvorjen v hiperpovezavo – vsak uporabnik, ki klikne na povezavo, je

preusmerjen na drugo stran, kar je določeno z atributom vrednost gradnika <asp:ListItem>.

Vrednost HyperLink spremeni vsako alinejo seznama v hiperpovezavo, ki poroča tej isti

strani.


3.2 Spletni gradnik HiddenField

Z namenon ohranjanja stanja oziroma evidenčnega upravljanja spletnih strani

razvijalci že vrsto let uporabljajo skrita polja. Element <input type="hidden"> je idealen za

hranjenje predmetov, ki nimajo nobenega varnostnega konteksta. Ti predmeti so vsebnik za

podatke , ki jih želimo hraniti na strani sami, namesto, da bi uporabili objekt Session.

Primer 3.1 je primer, kako uporabimo spletni gradnik HiddenField, da vzamemo

GUID, katerega vrednost se, ko se končni uporabnik pomika skozi aplikacijo, preprosto

prenaša od strani do strani [1].

<%@ Page Language=”C#”%>

<script runat=”server”>

protected void Page_Load(object sender, EventArgs e)

{

HiddenField1.Value = System.Guid.NewGuid().ToString();

}

</script>

<html xmlns=”http://www.w3.org/1999/xhtml” >

<head runat=”server”>

<title>HiddenField Server Control</title>

</head>

<body>

<form id=”form1” runat=”server”>

<asp:HiddenField ID=”HiddenField1” Runat=”Server” />

</form>

</body>

</html>

Primer 3.1: Uporaba gradnika HiddenField


3.3 Spletni gradnik FileUpload

V ASP.NET 1.0/1.1 je bilo nalaganje datotek možno z uporabo HTML spletnega

gradnika FileUpload. Ta gradnik je na spletno stran dodal element <input type="file">, da je

končnemu uporabniku omogočil nalaganje datotek v strežnik. Za uporabo te datoteke pa je

bilo treba stran zelo spremeniti. Elementu <form> je bilo na strani npr. treba dodati atribut

enctype="multipart/form. ASP.NET 2.0 uvaja nov spletni gradnik FileUpload, s katerim je

proces nalaganja v strežnik še lažji. Ko podajate možnosti strani za nalaganje datotek,

preprosto vključite nov gradnik <asp:FileUpload> in ASP.NET poskrbi za ostalo, vključno z

dodajanjem atributa enctype elementu <form> na strani.

Nalaganje datotek z uporabo gradnika FileUpload:

Ko se datoteka naloži v strežnik, lahko dostopamo tudi do lastnosti naložene datoteke

in jih posredujemo končnemu uporabniku ali pa te vrednosti uporabimo sami za kodo v

ozadju strani. Primer 3.2 prikazuje primer uporabe novega gradnika FileUpload. Stran

vsebuje en gradnik FileUpload, poleg tega pa še gradnika Button in Label [1].

<%@ Page Language=”C#”%>


protected void Button1_Click(object sender, EventArgs e)

{

if (FileUpload1.HasFile)

try {

FileUpload1.SaveAs(“C:\\Uploads\\” + FileUpload1.FileName);

Label1.Text = “File name: “ +

FileUpload1.PostedFile.FileName + “<br>” +

FileUpload1.PostedFile.ContentLength + “ kb<br>” +

“Content type: “ +

FileUpload1.PostedFile.ContentType;

}

catch (Exception ex) {

Label1.Text = “ERROR: “ + ex.Message.ToString();


}

else

{

Label1.Text = “Niste definirali datoteke.”;

}

}

Primer 3.2 : Uporaba gradnika FileUpload

3.4 Spletni gradnik MultiView in View

Spletna gradnika MultiView in View delujeta skupaj, da omogočita vklop/izklop

odsekov ASP.NET strani. Vklapljanje in izklapljanje odsekov, kar pomeni aktiviranje in

deaktiviranje vrste gradnikov View znotraj gradnika MultiView, je podobno spreminjanju

vidljivosti gradnika Panel. Pri nekaterih operacijah pa se nam bo upravljanje in delo zdelo

lažje z gradnikom MultiView.

Pri odjemalcu se odseki ne spreminjajo, se pa ob obveščanju strežnika. V vsak pogled

lahko postavimo poljubno število elementov in gradnikov, končni uporabnik pa lahko s temi

pogledi dela na osnovi zaporednih številk, ki jih določimo pogledom. Če delamo z Visual

Studio 2005, lahko gradnik MultiView povlečemo in spustimo na oblikovno površino, potem

pa vanj povlečemo in spustimo poljubno število gradnikov View. Elemente, ki jih želimo,

postavimo znotraj gradnikov View. Primer je prikazan na sliki 3.1. Svoje gradnike lahko

ustvarjamo tudi neposredno v kodi.


Slika 3.1: Gradnika MultiView in View

3.5 Spletni gradnik Wizard

Tudi spletni gradnik Wizard nam, podobno kot gradnik Multiview, omogoča

ustvarjanje zaporedja korakov, ki je prikazano končnemu uporabniku. Pri spletnih straneh

gre za ali prikazovanje ali vnos podatkov, mi pa v veliko primerih nočemo prikazati vseh

informacij hkrati – niti ne želimo od končnega uporabnika zbrati vsega hkrati. Pri

ustvarjanju procesa, ki za izvedene korake vključuje logiko, za izvedbo uporabimo gradnik

Wizard. Ko ga prvič uporabimo, bodimo pozorni na to, da dovoljuje veliko večjo stopnjo

prikrojevanja po meri kot gradnik MultiView. V najpreprostejši obliki je gradnik Wizard

lahko le element <asp:Wizard> s poljubnim številom elementov <asp:WizardStep>. Primer

3.3 ustvari gradnik Wizard, ki deluje v treh korakih [1].


<%@ Page Language=”VB”%>



<title>Wizard server control</title>

</head>

<body>


<asp:Wizard ID=”Wizard1” Runat=”server” SideBarEnabled=”true”

ActiveStepIndex=”0”>

<WizardSteps>

<asp:WizardStep Runat=”server” Title=”Step 1”>

This is the first step.</asp:WizardStep>


This is the second step.</asp:WizardStep>


This is the third and final step.</asp:WizardStep>

</WizardSteps>

</asp:Wizard>

</form>

</body>

</html>

Primer 3.3: Primer gradnika Wizard

V tem primeru so trije koraki definirani z gradnikom <asp:WizardSteps>. Vsak korak

vsebuje vsebino – v tem primeru samo tekst, čeprav lahko vstavimo, karkoli želimo, npr.

druge spletne ali celo uporabniško definirane gradnike. Vrstni red, v katerem so definirani

koraki Wizard, je popolnoma odvisen od vrstnega reda, v katerem se pojavijo v elementu

<WizardSteps>. Sam element <asp:Wizard> vsebuje nekaj pomembnih atributov. Prvi je

SideBarEnabled. V tem primeru je nastavljen na True, kar pomeni, da pomožni navigacijski

sistem v prikazanem gradniku omogoča končnemu uporabniku hitro pomikanje na druge

korake v procesu. Atribut ActiveStepIndex gradnika Wizard določa čarovnikov prvi korak.

V tem primeru je prvi korak določen z indeksom 0.


Dodajanje headerja gradniku Wizard

Z atributom HeaderText v glavni element <asp:Wizard> nam gradnik Wizard

omogoča postavitev headerja v gradnik, kar ponazarja primer 3.4.

<asp:Wizard ID=”Wizard1” Runat=”server” SideBarEnabled=”true”

ActiveStepIndex=”0”

HeaderText=” Step by Step with the Wizard control ”

HeaderStyle-BackColor=”DarkGray” HeaderStyle-Font-Bold=”true”

HeaderStyle-Font-Size=”20”>

Primer 3.4: Primer headerja v gradniku Wizard

Uporaba gradnika Wizard za prikaz elementov delovnega prostora

Gradnik Wizard si za vsak korak posebej zapomni vsak vnos v elemente delovnega

prostora in nam omogoča, da v zadnjem koraku shranimo rezultate celotnega delovnega

prostora. Pomeni pa tudi, da so potem, ko končni uporabnik pritisne gumb Nazaj, podatki, ki

jih je v delovni prostor vnesel pred tem, še zmeraj tam in jih je možno spreminjati.

Uporabimo postopni proces, ki vnese informacije o delovnem prostoru tako, da uvede proces

registracije. Zadnji korak v procesu shrani rezultate v bazo podatkov po naši izbiri.

3.6 Spletni gradnik ImageMap

Spletni gradnik ImageMap je v ASP.NET nov. Omogoča spreminjanje slike v

navigacijskem meniju. V preteklosti bi veliko razvijalcev sliko razdelilo na več delov in jih

dalo skupaj v tabelo, tako da bi dele slike znova sestavili v eno samo sliko. Ko bi končni

uporabnik kliknil na posamezni del celotne slike, bi aplikacija razbrala, kateri del slike je bil

izbran in bi delovanje prilagodila samo za to izbiro.

Z novim gradnikom ImageMap lahko vzamemo posamezno sliko in na sliki s

koordinatami določimo posamezna žarišča. Primer 3.5 prikazuje, kako se določajo deli slike

[1].



<title>ImageMap Control</title>

</head>

<body>


<asp:ImageMap ID=”Imagemap1” Runat=”server” ImageUrl=”kids.jpg”

Width=”300” OnClick=”Imagemap1_Click” HotSpotMode=”PostBack”>

<asp:RectangleHotSpot Top=”0” Bottom=”225” Left=”0” Right=”150”

AlternateText=”Henri” PostBackValue=”Henri”>

</asp:RectangleHotSpot>

<asp:RectangleHotSpot Top=”0” Bottom=”225” Left=”151” Right=”300”

AlternateText=”Sofia” PostBackValue=”Sofia”>

</asp:RectangleHotSpot>

</asp:ImageMap>

</form>

</body>

</html>

C#

<%@ page language=”C#”%>


protected void Imagemap1_Click(object sender,

System.Web.UI.WebControls.ImageMapEventArgs e) {

Response.Write(“Izbrali ste: “ + e.PostBackValue);

}

Primer 3.5: Določanje delov slike, ki jih je mogoče klikniti

Gradnik ImageMap mam omogoča določanje žarišč na več različnih načinov.

Gradnik določi zgornje, spodnje, leve in desne koordinate pravokotnika, ki bo žarišče. Poleg

gradnika <asp:RectangleHotSpot> lahko uporabimo še gradnika <asp: CircleHotSpot> in

<asp:PolygonHotSpot>. Vsak gradnik določa koordinate, primerne njegovi obliki.

Potem ko na sliki definiramo žarišča, lahko, če končni uporabnik klikne na žarišče,

odgovorimo na več načinov. Najprej v izvornem elementu <asp:ImageMap> z uporabo

atributa HotSpotMode določimo, kako naj se kliki na žarišča obravnavajo. Atribut


HotSpotMode lahko zavzame vrednosti PostBack, Navigate ali InActive. V prejšnjem

primeru je vrednost HotSpotMode nastavljena na PostBack, kar pomeni, da želimo potem,

ko končni uporabnik klikne na žarišče, posredovati strežniku in takrat obravnavati klik. Ker

je lastnost HotSpotMode nastavljena na PostBack in smo ustvarili več žarišč, moramo

določiti, katero žarišče je izbrano. To določimo tako, da vsakemu od žarišč

(<asp:RectangleHotSpot>) dodelimo vrednost posredovanja z atributom PostBackValue.

Atribut PostBackValue je prav tako pomožni tekst, ki se, ko končni uporabnik premakne

miško čez žarišče, v brskalniku pojavi (v rumenem okencu) neposredno pod miškinim

kurzorjem. Potem ko uporabnik klikne enega od žarišč, posledična obravnava prikaže

vrednost, ki je bila izbrana, izpiše se z Response.Write.

Namesto, da bi posredovali strežniku informacijo o kliku, lahko potem, ko je

posamezno središče izbrano, gremo na popolnoma drug URL. Da bi to dosegli, spremenimo

atribut HotSpotMode v glavnem elementu <asp:ImageMap> na vrednost Navigate. Potem pa

v elementu <asp:RectangleHotSpot> preprosto uporabimo atribut NavigateUrl in določimo

lokacijo, kamor naj bo končni uporabnik usmerjen, če klikne posamezno žarišče.

3.7 Delo s predlogami strani

Vizualna nasleditev je nova izboljšava za spletne strani, za katero je poskrbljeno z

novimi dodatki v ASP.NET 2.0. Pravzaprav lahko ustvarimo le šablono strani, ki jo v svoji

aplikaciji lahko uporabimo kot temelj za poljubno število ASP.NET vsebinskih strani. Te

šablone, imenovane predloge strani, povečujejo produktivnost s tem, da nam olajšujejo

ustvarjanje in upravljanje aplikacij, potem ko so le-te ustvarjene.

Visual Studio 2005 vključuje vso podporo za oblikovalce predlog strani, kar bolj kot

kadarkoli prej obogati razvijalsko izkušnjo. V tem poglavju pobliže obravnavamo uporabo

predlog strani v aplikaciji z največjim izkoristkom ter začnemo z razlago prednosti predlog

strani.

Predloge strani so preprost način ustvarjanja šablone, ki jo lahko uporabimo za poljubno

število ASP.NET strani v aplikaciji. Pri delu s predlogami strani ustvarimo predlogo

datoteke, ki se navezuje na podstrani ali vsebinske strani. Predloge strani na koncu datoteke


uporabljajo pripono .master, medtem ko vsebinske strani na koncu uporabljajo pripono

.aspx, ki smo je vajeni.

Vse, kar želimo porazdeliti po šabloni, damo v datoteko .master. To lahko vključuje

predele z glavo, navigacijo in nogo, ki se uporabljajo po vsej spletni aplikaciji. Vsebinska

stran tako vsebuje vso vsebino strani razen elementov predloge strani. Ko ga zaženemo,

orodje ASP.NET te elemente kombinira v eno samo stran za končnega uporabnika. Slika 3.4

prikazuje diagram delovanja tega procesa. Ena od prijetnih strani pri delu s predlogami strani

je, da lahko, ko ustvarjamo vsebinske strani, v IDE vidimo navidezno šablono. Ker lahko

medtem, ko delamo na njej, vidimo celotno stran, je veliko laže ustvariti vsebinske strani, ki

uporabljajo šablono. Med delom na vsebinski strani so vsi šablonski predmeti osenčeni sivo

in jih ni mogoče urejati. Edini predmeti, ki jih je mogoče spreminjati, so v šabloni jasno

prikazani. Ta področja, ki jih je možno obdelati, imenovana tudi vsebinska področja, so

prvotno definirana v sami predlogi strani. Znotraj predloge strani določimo področja strani,

ki jih lahko uporabljajo vsebinske strani. Če želimo, lahko imamo na strani več vsebinskih

področij.

Z izdajo ASP.NET 2.0 so predloge strani zdaj mogoče, saj .NET Framework zdaj

podpira tudi delne razrede. To je možnost, da ob zagonu dva razreda strnemo v enega

samega. Z uporabo te nove možnosti orodje ASP.NET ob zagonu vzame dva razreda strani

in ju združi v en sam razred, kot kaže slika 3.2 [1].


Slika 3.2: Združevanje razredov

Podjetjem in organizacijam se bo uporaba predlog strani zdela idealna, saj ta

tehnologija podrobno poustvarja njihove tipične poslovne zahteve. Veliko podjetij ima nek

splošen izgled, ki ga uporabljajo skozi ves intranet. Zdaj lahko oddelkom svojega podjetja ob

ustvarjanju oddelčnega odseka intraneta v uporabo ponudijo datoteko .master. Ta proces

podjetju omogoči, da lažje obdrži konsistenten izgled in vzdušje po vsem spletu.

Kodiranje predloge strani

Predlogo strani lahko sestavimo v kateremkoli tekstovnem urejevalniku, kot je npr.

Notepad ali Visual Web Developer Express Edition, lahko pa uporabimo tudi Visual Studio

2005. Predloge strani lahko svojim projektom dodajamo na enak način kot običajne strani s

končnico aspx; ko svoji aplikaciji dodamo novo datoteko, izberemo možnost »Master«.

Ker je prav tako kot vsaka druga stran s končnico »aspx«, nam pogovorno okno

Dodaj Nov Predmet (Add New Item) omogoča, da izbiramo med predlogo strani, ki


uporablja medvrstični kodni model, in predlogo strani, ki svojo kodo spravlja v ločeno

datoteko.

Če kode svojega gradnika ne spravljamo v ločeno datoteko, pomeni, da za stran, ki jo

ustvarjamo, uporabljamo medvrstični kodni model. Ta opcija ustvari posamezno stran s

končnico »master«. Če se odločimo za možnost, da svojo kodo spravljamo v ločeno

datoteko, to pomeni, da za stran, ki jo ustvarjamo, uporabljamo novi model kode v ozadju.

Če izberemo potrditveno polje Postavi kodo v ločeno datoteko (Place Code In Separate File),

s tem ustvarimo posamezno stran s končnico »master« skupaj z navezano datoteko s

končnico »master.vb« ali »master.cs«.

Kodiranje vsebinske strani

Zdaj ko imamo v svoji aplikaciji primerno predlogo strani, lahko to novo šablono

uporabimo za poljubne vsebinske strani v aplikaciji. V Solution Explorerju desno kliknemo

aplikacijo in izberemo Add New Item, da v aplikaciji ustvarimo novo vsebinsko stran. Za

ustvarjanje vsebinske strani ali strani, ki predlogo strani uporablja za šablono, iz seznama

možnosti v pogovornem oknu Dodaj Nov Predmet izberimo tipičen spletni delovni prostor.

Namesto, da bi ustvarili tipični spletni delovni prostor, pa obkljukamo potrditveno polje

Izberi Predlogo Strani. To nam omogoči, da ta spletni delovni prostor kasneje navežemo na

neko predlogo.

Potem ko poimenujemo svojo vsebinsko stran in v pogovornem oknu Add New Item

kliknemo gumb Add, se prikaže pogovorno okno Select Page Template. To pogovorno okno

nam omogoča, da si izberemo predlogo strani, iz katere ustvarimo svojo vsebinsko stran.

Izbiramo med razpoložljivimi predlogami strani, ki so vsebovane v aplikaciji.

3.8 Teme in preobleke

Teme so podobne stilnim predlogam, ki omogočajo definiranje vizualnih slogov za

spletne strani. Toda teme gredo še dalje od stilnih predlog, saj nam na straneh aplikacij


omogočajo uporabo slogov, grafike in celo datotek samih stilnih predlog. ASP.NET teme

lahko uporabimo na ravni aplikacije, strani ali spletnega gradnika [2].

Ustvarjanje lastnih tem

Ustvarjanje tem v ASP.NET je precej preprost proces – čeprav pa včasih zahteva

nekaj umetniških sposobnosti. Teme, ki jih ustvarimo, lahko uporabimo na ravni aplikacije,

strani ali spletnega gradnika. So način, kako na vso aplikacijo prenesemo konsistenten izgled

ter vzdušje.

Ustvarjanje preobleke:

Preobleka je definicija slogov, ki se uporabljajo za spletne gradnike na ASP.NET

strani. Preobleke lahko delujejo v kombinaciji z datotekami stilnih predlog ali s slikami. Da

bi ustvarili temo za uporabo v vaših ASP.NET aplikacijah, uporabimo v mapi s temami

samo eno datoteko s preoblekami. Datoteka s preoblekami ima lahko poljubno ime, a mora

imeti datotečno pripono »skin«. Primer je ponazorjen na primeru 3.6 [2].

<asp:Label Runat=”server” ForeColor=”#004000” Font-Names=”Verdana”

Font-Size=”X-Small” />

<asp:Textbox Runat=”server” ForeColor=”#004000” Font-Names=”Verdana”

Font-Size=”X-Small” BorderStyle=”Solid” BorderWidth=”1px”

BorderColor=”#004000” Font-Bold=”True” />

<asp:Button Runat=”server” ForeColor=”#004000” Font-Names=”Verdana”

Font-Size=”X-Small” BorderStyle=”Solid” BorderWidth=”1px”

BorderColor=”#004000” Font-Bold=”True” BackColor=”#FFE0C0” />

Primer 3.6: Primer preobleke

To je le primerek tega, kar naj bi vsebovala preobleka. Da bi jo lahko uporabili v

pravi aplikaciji, moramo vsako opcijo spletnega gradnika definirati. V tem primeru imamo

definicijo, primerno za tri različne vrste spletnih gradnikov: Label, TextBox in Button.


Podobno kot definicije običajnih spletnih gradnikov, ki jih vstavljamo v tipično stran

s končnico »aspx«, morajo tudi definicije za te gradnike vsebovati atribut Runat = "server".

Če ta atribut določimo v preoblečeni verziji gradnika, ga s tem vključimo tudi v spletni

gradnik, ki ga dajemo na aspx stran, ki to temo uporablja. Pozorni moramo biti tudi na to, da

pri preoblečeni verziji gradnika ni podan noben atribut ID. Če atribut ID tu podamo, se, ko

stran to temo skuša uporabiti, pojavi napaka.

Vključevanje datotek s stilnimi predlogami v teme

Poleg definicij za spletne gradnike, ki jih ustvarimo iz dokumenta preobleke, lahko

ustvarimo nadaljnje definicije z uporabo stilnih predlog. Pri uporabi dokumenta s končnico

»skin« smo lahko določili le sloge, povezane s spletnimi gradniki in nič drugega. A

razvijalci na svojih ASP.NET straneh ponavadi uporabljajo še vse kaj drugega kot spletne

gradnike. ASP.NET strani so, na primer, ponavadi zgrajene iz HTML gradnikov.

Za temo, ki bi šla dlje od spletnih gradnikov, moramo nadalje določiti slog teme, tako

da se HTML spletni gradniki spreminjajo v skladu s temo. To dosežemo tako, da v mapo

Skins damo datoteko s stilnimi predlogami.

Ustvarjanje dokumentov s stilnimi predlogami za teme je z uporabo Visual Studia

2005 precej preprosto. Desno kliknemo datoteko s temo in izberemo Dodaj Nov Predmet

(Add New Item). Iz seznama možnosti izberemo možnost StyleSheet in jo poimenujemo. To

ustvari prazno datoteko s končnico »css«. Pogovorno okno, ki se prikaže z Visual Studio

2005, omogoča, da v celoti definiramo svojo stran s stilno predlogo, ne da bi nam bilo treba

dejansko kaj programirati.


3.9 Dostop do podatkov v ASP.NET 2.0

3.9.1 Kaj je novega pri dostopu do podatkov

Pri ASP.NET 2.0 je Microsoft uporabil koncept povezovanja podatkov in ga razširil,

da bi olajšal razumevanje povezovanja podatkov in njegovo uporabo. ASP.NET 2.0 uvaja

novo plast abstrakcije podatkov, imenovano podatkovni gradniki. To poglavje obravnava vse

razpoložljive podatkovne gradnike, opisuje pa tudi druge spremembe podatkovnega

navezovanja v ASP.NET 2.0. Kaže tudi, kako lahko uporabimo podatkovne gradnike, da

zlahka in hitro povežemo podatke s povezovalnimi gradniki. To poglavje se osredotoča tudi

na zmogljivost več novih navezovalnih gradnikov List, ki so vključeni v ASP.NET 2.0, kot

so npr. gradniki GridView, DetailsView in FormView [1].

3.9.2 Podatkovni gradniki

Pri ASP.NET 1.0/1.1 smo morali izvesti operacijo povezovanja podatkov tako, da

smo za priklic objektov DataReader ali DataSet napisali neko kodo za dostop do podatkov;

nato smo ta podatkovni objekt povezali s spletnim gradnikom, kot je npr. DataGrid,

DropDownList ali ListBox. Če smo povezane podatke želeli posodobiti ali izbrisati, smo

morali za to napisati kodo za dostop do podatkov.

ASP.NET 2.0 uvaja dodaten sloj abstrakcije z uporabo podatkovnih gradnikov. Ti

gradniki abstrahirajo uporabo podatkovnega ponudnika, na katerem temeljijo, kot sta npr.

podatkovni ponudnik SQL ali OLEDB. To pomeni, da se nam ni treba več ubadati s kakoji

in zakaji uporabe podatkovnih ponudnikov. Namesto tega podatkovni gradniki za nas

opravijo vso težko delo. Vedeti moramo le, kje so naši podatki, in, če je to potrebno, kako

sestaviti poizvedbo za izvajanje operacij CRUD (Create, Retrieve, Update in Delete).

Vsak od petih podatkovnih gradnikov v ASP.NET 2.0 se uporablja za posebno vrsto

dostopa do podatkov. Tabela 3.1 razvršča in opisuje vsakega od podatkovnih gradnikov,

vključenih v ASP.NET 2.0.


Ime Gradnika Opis

SQLDataSource Dostop do podatkovnih baz: ODBC, OLE

DB, SQL Server

ObjectDataSource Dostop do poslovnih objektov ali drugih

podatkov, ki vrnejo podatke

XmlDataSource Dostop do XML dokumetov

SiteMapDataSource Dostop do sitemap podatkov

Tabela 3.1: Podatkovni gradniki

Podatkovni gradnik SQLDatasource

Podatkovni gradnik SQL je podatkovni gradnik, ki ga uporabimo, če so naši podatki

hranjeni v SQL Server, Oracle Server, podatkovnem viru ODBC, OLE DB, ali v podatkovni

bazi Windows SQL CE. Gradnik odpre čarovnika, preprostega za uporabo, ki nas vodi skozi

proces konfiguracije, ali pa lahko gradnik ročno priredimo tako, da spremenimo atribute

gradnika neposredno v Codeview. Gradnik uporabljamo tako, da odpremo stran s končnico

»aspx« znotraj projekta spletnega mesta Visual Studio in povlečemo gradnik

SQLDataSource iz orodjarne na delovni prostor. Visual Studieva orodjarna je razdeljena v

funkcionalne skupine, tako da vse s podatki povezane gradnike najdemo nameščene v

odseku Data.

Konfiguracija podatkovne povezave

Potem ko smo spustili gradnik na spletno stran, mu povemo, kakšno povezavo naj

uporabi Wizard za konfiguracijo podatkovnega vira, kot je prikazano na sliki 3.5. Tega

čarovnika zaženemo tako, da izberemo možnost Configure Data Source iz menija oznake

podatkovnega gradnika. Potem ko se čarovnik odpre, bi morali ustvariti povezavo s

podatkovno bazo. Potem ko se čarovnik odpre, lahko iz spustnega seznama izberemo že


obstoječo povezavo ali pa ustvarimo novo. Če kliknemo gumb Nova Povezava (New

Connection), se pojavi pogovorno okno Connection Properties, prikazano na sliki 3.3. Od tu

lahko nastavimo vse lastnosti nove povezave s podatkovno bazo.

Slika 3.3: Konfiguracija podatkovne povezave


Slika 3.4: Ustvarjanje povezave

Podatkovni gradnik XML (XML Datasource)

Podatkovni gradnik XML nam zagotavlja preprost način povezovanja XML

dokumentov, najsi znotraj pomnilnika ali pa nameščenih na fizični pogon. Gradnik nam

zagotavlja številne lastnosti, ki nam olajšajo določanje XML datoteke s podatki in XSLT

pretvorne datoteke za preoblikovanje izvornega XML v ustreznejši format. Lahko začnemo

tudi XPath poizvedbo, da izberemo le določeno podskupino podatkov. Za konfiguracijo

gradnika XmlDataSource lahko uporabimo čarovnika ConfigureData, kot je prikazano na

sliki 3.5 [5].


Slika 3.5: Podatkovni gradnik XmlDatasource

Podatkovni gradnik ObjectDataSource

Gradnik ObjectDataSource je eden novih, najbolj vroče pričakovanih podatkovnih

gradnikov v ASP.NET 2.0. Daje nam možnost povezovanja podatkovnih gradnikov s

srednjeslojnimi poslovnimi objekti , ki jih lahko ustvarjamo s programi, kot so O/R

preslikovalniki. To je bilo v ASP.NET 1.0/1.1 zmeraj težko doseči, toda gradnik

ObjectDataSource to olajša – hkrati pa ohranja glavne posebnosti podatkovnih gradnikov,

kot sta npr. predpomnjenje in ostranjevanje. Gradnik omogoča, da za izbiro poslovnega

objekta določimo podatkovne metode, kot so Delete, Update, Insert ter Select, ter določitev

načina vračila podatkov, kjer pa lahko vračamo podatke v obliki DataSet ali DataReader, kar

je prikazano na sliki 3.6.


Slika 3.6: Definiranje podatkovnih metod

Gradnik SiteMapDataSource

Gradnik SiteMapDataSource nam omogoča, da delamo s podatki, shranjenimi v

konfiguracijski datoteki SiteMap, če le-to imamo. To zna biti uporabno, če ob zagonu

spreminjamo podatke zemljevida spletišča, ki najbrž temeljijo na uporabnikovih privilegijih

oziroma statusu.

Pozorni moramo biti na dva predmeta, ki se tičeta gradnika SiteMapDataSource.

Prvič, ta ne podpira nobene možnosti predpomnjenja podatkov, ki obstajajo v drugih

razpoložljivih podatkovnih gradnikih, tako da svojih podatkov o zemljevidu spletišča ne

moremo samodejno predshraniti. Drugič, gradnik SiteMapDataSource nima nobenih

konfiguracijskih čarovnikov kot drugi podatkovni gradniki. To pa zato, ker se gradnik


SiteMap lahko poveže le s SiteMap datoteko s konfiguracijskimi podatki našega spletnega

mesta, tako da ni možna nobena druga konfiguracija.

Shranjevanje informacij o povezavi

V ASP.NET 1.0/1.1 je Microsoft uvedel datoteko web.config kot način shranjevanja

podatkov o konfiguraciji aplikacije v format, ki ga bo moč brati in prenašati. Veliko ljudi je

hitro spoznalo, da je datoteka web.config imeniten kraj za shranjevanje informacij, kot so

npr. informacije o povezavi s podatkovno bazo, ki jo uporabljajo njihove aplikacije. Iz

aplikacije je bila zlahka dostopna, za konfiguracijske podatke je ustvarila eno osrednjo

lokacijo in jo je bilo zlahka mogoče spremeniti že z urejanjem XML [5].

Kljub temu, da so bile vse to prednosti, pa je bilo tudi nekaj slabosti. Prvič, nobena

informacija v datoteki web.config ne more biti natipkana krepko. Zato je bilo težko najti

podatkovne tipkarske napake v aplikaciji, dokler se ni med izvajanjem pojavila napaka.

Drugi problem je bil ta, da so kljub temu, da je bila datoteka web.config zaščitena pred

dostopom brskalnikov (ne more je podati Internet Information Server), bili podatki iz

datoteke v celoti vidni vsakomur, ki je imel na spletnem strežniku dostop do datoteke.

V ASP.NET 2.0 se je Microsoft skušal spopasti s temi slabostmi v datoteki

web.config. Ker so informacije o povezavi s podatkovno bazo pogosto hranjene v datoteki

web.config, imamo sedaj v tej datoteki popolnoma nov konfiguracijski odsek,

<ConnectionStrings>, posebej namenjen shranjevanju niza informacij o povezavi.

Če pregledamo svojo datoteko web.config, bi v odseku <ConnectionStrings> morali

videti že vsaj en povezovalni niz, saj je naš primerek naročil čarovniku Data Connection, naj

povezave shrani v datoteko web.config.

3.10 Uporaba gradnikov Bound List skupaj s podatkovnimi gradniki

Novi podatkovni gradniki zares zasijejo, ko jih kombiniramo z gradniki BoundList,

vključenimi v ASP.NET 2.0. Ta kombinacija nam omogoča, da svoj podatkovni vir


deklarativno povežemo s povezovalnim gradnikom, ne da bi sploh napisali eno samo vrstico

kode za C# ali VB.

Za povezovanje podatkov še zmeraj lahko z gradnikom List uporabljamo dobro znano

metodo DataBind. Pravzaprav je bila ta metoda celo izboljšana, tako da vključuje

Bodeanovo preobremenitev, ki nam omogoča vključitev ali izključitev možnosti

povezovanja podatkov. To nam omogoča, da, če ne uporabljamo nobenih dogodkov

povezovanja, izboljšamo učinkovitost naše aplikacije.

3.10.1 GridView

Pri ASP.NET 1.0/1.1 Microsoft uvaja vrsto novih spletnih gradnikov, zasnovanih, da

bi bili razvijalci bolj produktivni. Eden najbolj priljubljenih gradnikov je DataGrid. S tem

enim gradnikom smo lahko prikazali celotno zbirko podatkov, zlahka dodajali razvrščanje in

ostranjevanje ter izvajali urejanje. Kljub temu, da je bila ta nova funkcionalnost dobra, je

veliko opravil še vedno zahtevalo, da razvijalec napiše precejšnjo količino kode, da je lahko

to napredno uporabnost izkoristil.

Za ASP.NET je Microsoft vzel osnoven DataGrid in ga izboljšal tako, da je ustvaril

nov spletni gradnik, imenovan GridView. Ta novi gradnik še bolj olajša uporabo naprednih

DataGrid posebnosti, večinoma, ne da bi morali napisati eno samo vrstico kode. Dodaja celo

nekaj novih posebnosti.

Prikaz podatkov z GridView

Gradnik GridView povlečemo na oblikovno površino ASP.NET spletne strani. Za

povezovanje z mrežo moramo izbrati podatkovni gradnik. Potem ko GridView dodelimo

podatkovni vir, opazimo številne spremembe. Najprej GridView spremeni svoj

prikazovalnik časa tako, da prikazuje podatke, ki jih poda podatkovni gradnik, ki je za to

zadolžen. Če bi se podatkovna shema za podatkovnim gradnikom kdaj spremenila, lahko

uporabimo GridView možnost Refresh Schema, da mrežo prisilimo, da se ponovno nariše


glede na novo podatkovno shemo. Drugič, GridView pametna oznaka ima zdaj dodatne

možnosti za formatiranje, ostranjevanje, sortiranje in selekcijo [1].

Omogočitev sortiranja GridView po stolpcih

Sposobnost sortiranja podatkov je eno najosnovnejših orodij, ki jih imajo uporabniki

za navigacijo skozi veliko količino podatkov. Z gradnikom DataGrid je sortiranje v mrežo

po stolpcih relativno lahka naloga, Gradnik GridView pa je vse skupaj popeljal še za korak

dalje. Za razliko od uporabe DataGrid, kjer smo morali ustaljen postopek sortiranja kodirati,

da smo v tej mreži vklopili sortiranje po stolpcih, zdaj atribut AllowSorting preprosto

nastavimo na True. Gradnik za vso sortirno logiko poskrbi interno.

Omogočitev GridView ostranjevalca (Pager)

Še ena splošna navigacijska posebnost, zaradi katere se GridView zelo izboljša, je

ostranjevanje. Čeprav je izvajanje ostranjevanja z uporabo DataGrid le-to zelo poenostavilo

(še posebej v primerjavi z ostranjevanjem v ASP), pa GridView to še olajša s svojim

atributom AllowPaging. Ta atribut je možno vklopiti tako, da ga gradniku GridView dodamo

v načinu HTML ali pa obkljukamo potrditveno polje EnablePaging v GridView oznaki.

Omogočitev ostranjevanja v gradniku GridView privzame velikost strani na 10 zapisov in na

dno mreže doda ostranjevalca.

Stolpci po meri v GridView

Če iz oznake gradnika GridView izberemo povezavo Add New Column, se prikaže

še en preprost delovni prostor – pogovorno okno AddField z možnostmi, ki nam omogočajo,

da v mrežo dodajamo popolnoma nove stolpce. Glede na to, kateri tip polja izberemo iz

spustnega seznama, nam pogovorno okno ponudi primerne možnosti za tip tistega stolpca.

Če želimo, dodamo hiperpovezavo, tako da iz spustnega seznama izberemo HyperLinkField.

Pogovorno okno AddField se spremeni in nam dovoli dostop do podatkov hiperpovezave,

vključno z URL, podatkovnim poljem in formatirnim nizom za tisti stolpec.


Urejanje GridView podatkov po vrsticah

Ne le, da uporabniki želijo videti podatke v brskalniku, imeti hočejo tudi možnost, da

podatke urejajo in spremembe shranijo nazaj v shrambo podatkov. Dodajanje možnosti

urejanja v DataGrid ni bilo nikoli lahko, a je bilo dovolj pomembno, da so razvijalci to

pogosto poskušali z gradnikom GridView.

Z gradnikom GridView je urejanje podatkov, ki jih vsebuje mreža, zelo olajšano. Da

bi pokazali, kako zelo preprosto je, lahko obstoječo mrežo preuredimo tako, da lahko

urejamo odjemalčeve podatke, ki jih vsebuje. Najprej spremenimo svoj obstoječi podatkovni

gradnik SQL z dodajanjem atributa UpdateCommand. To podatkovnemu gradniku pove,

kateri SQL naj zažene, ko se od njega zahteva izvedba posodobitve. Navedek 3.5 prikazuje

program, s katerim dodamo atribut UpdateCommand. Pozorni moramo biti na to, da

UpdateCommand vključuje več parametrov, kot so npr. @ImePodjetja, @Država, @Regija

ter @OdjemalčevID. Le-ti nadomeščajo odgovarjajoče informacije, ki bodo prišle iz izbrane

vrstice v GridView. Da bi te parametre lahko uporabili, jih definiramo z uporabo elementa

UpdateParameters, prikazanem v primeru 3.7, ki deluje precej podobno kot element

SelectParameters [2].

<asp:SqlDataSource ID=”SqlDataSource1” Runat=”server”

SelectCommand=”SELECT * FROM [Customers]”

ConnectionString=”<%$ ConnectionStrings:AppConnectionString1 %>”

DataSourceMode=”DataSet”

UpdateCommand=”UPDATE [Customers] SET [CompanyName] = @CompanyName,

[ContactName] = @ContactName, [ContactTitle] = @ContactTitle,

[Address] = @Address, [City] = @City, [Region] = @Region,

[PostalCode] = @PostalCode, [Country] = @Country, [Phone] = @Phone,

[Fax] = @Fax WHERE [CustomerID] = @original_CustomerID”>

<UpdateParameters>

<asp:Parameter Type=”String” Name=”CompanyName”></asp:Parameter>

<asp:Parameter Type=”String” Name=”ContactName”></asp:Parameter>

<asp:Parameter Type=”String” Name=”ContactTitle”></asp:Parameter>

<asp:Parameter Type=”String” Name=”Address”></asp:Parameter>

<asp:Parameter Type=”String” Name=”City”></asp:Parameter>


<asp:Parameter Type=”String” Name=”Region”></asp:Parameter>

<asp:Parameter Type=”String” Name=”PostalCode”></asp:Parameter>

<asp:Parameter Type=”String” Name=”Country”></asp:Parameter>

<asp:Parameter Type=”String” Name=”Phone”></asp:Parameter>

<asp:Parameter Type=”String” Name=”Fax”></asp:Parameter>

<asp:Parameter Type=”String” Name=”CustomerID”></asp:Parameter>

</UpdateParameters>

</asp:SqlDataSource>

Primer 3.7: Element UpdateParameters

3.10.2 DetailsView

Spletni gradnik DetailsView je nov gradnik, povezan s podatki, ki nam omogoča

ogled enega podatkovnega zapisa naenkrat. Čeprav je GridView gradnik za pregledovanje

zbirke podatkov, se moramo biti v veliko primerih sposobni prebiti do posameznega zapisa.

Gradnik DetailsView nam to omogoča in zagotavlja precej podobno upravljanje podatkov in

možnosti prikaza kot GridView. Omogoča opravila, kot je npr. ostranjevanje, posodabljanje,

vstavljanje in brisanje podatkov.

Da bi začeli uporabljati DetailsView, povlečemo gradnik na oblikovno površino.

Tako kot pri GridView lahko za ustvarjanje ter nastavitev podatkovnega vira za gradnik

uporabimo oznako DetailsView. Za ta vzorec uporabljajmo samo podatkovni gradnik SQL,

ki smo ga uporabljali že za DataGrid. Če na tej točki zaženemo stran, vidimo, da gradnik

prikaže en zapis, in sicer prvi zapis, ki ga vrne naša poizvedba.


3.10.3 FormView

Gradnik FormView je nov gradnik, vključen v ASP.NET orodjarno. V osnovi deluje

kot gradnik DetailsView, v katerem se prikaže le posamezen podatkovni predmet iz

povezanega podatkovnega gradnika in omogoča dodajanje, urejanje in brisanje podatkov.

Kar ga dela edinstvenega, je to, da prikazuje podatke v šablonah po meri, kar daje veliko

večji nadzor nad tem, kako so podatki prikazani in urejani. Gradnik FormView vsebuje tudi

EditTemplate, ki nam omogoča, da določimo, kako se gradnik prikaže, ko vstopimo v način

Edit ali Insert.

3.10.4 Drugi s podatki povezani gradniki

ASP.NET 1.0/1.1 je vseboval veliko drugih gradnikov, ki jih je bilo moč povezati s

podatkovnimi viri. ASP.NET 2.0 je te gradnike obdržal, nekatere izboljšal ter orodjarni

dodal nekaj novih povezovalnih gradnikov.

Gradniki DropDownList, ListBox, RadioButtonList in CheckBoxList

Čeprav so gradniki ListBox, RadioButtonList in CheckBoxList od ASP.NET 1.0/1.1

do ASP.NET 2.0 v veliki večini ostali enaki, pa vsebujejo nekaj novih lastnosti. Poleg tega

ASP.NET 2.0 vsebuje tudi nova gradnika RadioButtonList in ListBox.

Ena od novih lastnosti, na voljo v vseh teh gradnikih, je lastnost

AppendDataBoundItems. Če to lastnost nastavimo na True, s tem gradniku RadioButtonList

naročimo, naj pripne s podatki povezan seznam predmetov na vse obstoječe statistično

navedene predmete, namesto, da bi jih prepisal, kot bi to storila verzija ASP.NET 1.0/1.1.

Še ena nova uporabna lastnost, ki je pri vseh treh gradnikih na voljo, je

DataTextFormatString, kar omogoča določanje formata niza za prikaz teksta predmetov

gradnika RadioButtonList.


TreeView

Še en vznemirljiv nov gradnik, vključen v ASP.NET 2.0 orodjarno, je gradnik

TreeView. Ker lahko TreeView prikaže le hierarhične podatke, ga lahko povežemo samo s

podatkovnima gradnikoma Xml in SiteMap.

Menu

Zadnji gradnik v tem delu je novi gradnik Menu. Kot gradnik TreeView je zmožen

prikazovanja hierarhičnih podatkov v vertikalnem pojavnem meniju. Podobno kot TreeView

ga lahko povežemo le s podatkovnima gradnikoma Xml in SiteMap.

3.11 Upravljanje s podatki z uporabo ADO.NET

ADO.NET je bil prvič uveden pri verziji Framework 1.0 in je zagotovil obsežen nabor

posebnosti, namenjenih upravljanju podatkov ali v živo, med povezavo s podatkovno bazo,

ali pa brez povezave. Z uvedbo ADO.NET 2.0 se je seznam že tako številnih posebnosti še

povečal. Nekaj na novo dodanih posebnosti vključuje možnost kopičenja ogromnih količin

podatkov iz različnih virov, kopičenja procesnih posodobitev v podatkovni bazi z manj

vračanja k strežniku podatkovne baze, ponovno uporabo iste povezave za več operacij, pa

tudi asinhron dostop do baze podatkov.

3.11.1 Osnovni ADO.NET imenski prostori in kategorije

ADO.NET vsebuje šest osnovnih imenskih prostorov. Poleg teh imenskih prostorov

pa ima lahko vsak nov podatkovni ponudnik svoj lasten imenski prostor. Tako npr.

podatkovni ponudnik Oracle.NET doda imenski prostor Microsoft.Data.OracleClient.

ADO.NET ima tri različne tipe razredov, ponavadi imenovanih Disconnected, Shared

in DataProviders. Razredi Disconnected ADO.NET Framework dajejo osnovno strukturo.


Dober primer tega tipa razreda je razred DataTable. Objekti tega razreda so zmožni hraniti

podatke, ne da bi bili odvisni od posebnega podatkovnega ponudnika in so porazdeljeni med

vse podatkovne ponudnike. Razredi DataProvider so namenjeni za delo z različnimi vrstami

podatkovnih virov. Uporabljajo se za izvajanje vseh z upravljanjem podatkov povezanih

opravil v posebnih podatkovnih bazah. Podatkovni ponudnik SQLClient na primer dela le z

bazo podatkov SQL Server. Podatkovni ponudnik vsebuje objekte Connection, Command,

DataAdapter in DataReader. Pri tipičnem ADO.NET programiranju najprej ustvarimo objekt

Connection in mu zagotovimo potrebne informacije, kot je npr. povezovalni niz. Potem

ustvarimo objekt Command in mu priskrbimo podrobnosti SQL ukaza, ki bo izveden. Ta

ukaz je lahko tekstovni ukaz SQL, shranjen postopek ali neposreden tabelni dostop. Če je

potrebno, lahko tem ukazom podamo tudi parametre.

Potem ko ustvarimo objekta Connection in Command, se moramo odločiti, ali naj

ukaz vrne niz rezultatov. Če ukaz niza rezultatov naj ne vrne, lahko ukaz preprosto izvedemo

tako, da prikličemo eno od njegovih metod Execute. Če pa naj ukaz niz rezultatov vrne, se

moramo odločiti, ali želimo niz rezultatov obdržati za prihodnjo uporabo, ne da bi bili

povezani z bazo podatkov. Če želimo niz rezultatov obdržati, moramo ustvariti objekt

DataAdapter in ga uporabiti, da napolnimo objekt DataSet ali DataTable. Ti objekti so

zmožni obdržati informacije v izklopljenem načinu. Kakorkoli, če ne želimo obdržati niza

rezultatov, temveč na hitro obdelati ukaz, lahko uporabimo objekt Command, da ustvarimo

objekt DataReader. Le-ta s podatkovno bazo potrebuje povezavo in deluje kot le naprej

gibajoči se, le branju namenjeni kurzor.

3.11.2 Uporaba objekta Connection

Objekt Connection ustvari povezavo s podatkovnim virom. Ta objekt potrebuje

potrebne informacije, da odkrije podatkovni vir in se vanj pravilno prijavi. Te informacije se

pridobijo preko povezovalnega niza. Lastnosti za razred SQLConnection so prikazane v

naslednji tabeli. SQLConnection je razred, ki je značilen za ponudnika SQLClient. Kot je

bilo povedano že prej v tem poglavju, je ponudnik SQLClient narejen za delo s

podatkovnimi bazami SQL Server 7.0 in več. Tabela 3.2 prikazuje lasnosti objekta

Connection.


Lastnost Opis

Datasource Vrne ime SQL Server podatkovne baze

Database Vrne ime podatkovne baze, potem ko je

povezava odprta

State Vrne trenutno stanje povezave. Možnosti so:

Broken, Closed, Connecting, Executing,

Fetching, in Open.

ConnectionString Niz povezave

Tabela 3.2 : Lastnosti objekta Connection

3.11.3 Na novo dodane posebnosti ADO.NET

Napredne posebnosti so dodane ADO.NET verziji 2.0 in zagotavljajo veliko

uporabnost, ki v prejšnjih verzijah preprosto ni bila na voljo. Te posebnosti so značilne za

strežnik podatkovne baze in razlaga se v tem poglavju osredotoča na strežnik podatkovne

baze SQL Server. Nekatere od teh posebnosti so odvisne od verzije 9.0 Microsoft Data

Access Components (MDAC).

Vznemirljiva posebnost, dodana ADO.NET 2.0, nam omogoča hitro in preprosto kopičenje

velikanskih količin podatkov iz skoraj vsakega vira v podatkovno bazo SQL Server. Če

dovolj dolgo pišemo kodo, se prebijamo skozi SQL Server Data Transformation Service

(DTS), da bi premaknili velikanske količine podatkov iz enega mesta na drugega.

Čeprav je DTS primeren za večino opravil, so si programerji zmeraj želeli, da bi

lahko napisali kodo po meri, ki bi pridobivala podatke v formatih po meri, jih med

vnašanjem poslovnih pravil obdelala in jih po možnosti prenesla v strežnik baze podatkov.

Takšno kodo vsekakor lahko napišemo s prejšnjimi verzijami ASP.NET, a smo omejeni na

uporabo metode Update objekta DataAdapter, ki se za vsak vpis, ki je vnešen, vrne k

strežniku spletne podatkovne baze. Lahko napišemo tudi ukaz po meri za vstavljanje in

posodabljanje teh vpisov brez uporabe objekta DataReader, a naš program mora potem za


vsak zapis narediti pot nazaj do strežnika baze podatkov. Prenos zapisov, večjih od 100KB,

zlahka vzame več ur in preplavi vse omrežje. Če je strežnik baze podatkov tako zaposlen, se

ob neskončnem čakanju, da se proces posodabljanja konča, izgublja produktivnost.

Masovno nalaganje podatkov iz raznih virov

Administratorji podatkovne baze so bili do sedaj vajeni raznih mehanizmov

prenašanja podatkov, kot je npr. DTS, ki je grafično okolje, in BCP (BulkCopy Program), ki

je dobra stran ukazne vrstice. S prihodom ADO.NET 2.0 zdaj lahko programerji napišejo

celotno kodo upravljanja za pridobivanje podatkov iz raznih virov. Lahko tudi masovno

kopirajo podatke v podatkovno bazo SQL Server – vse v najljubšem programerskem jeziku.

Imenski prostor SQLClient uvaja več novih razredov, ki nam omogočajo masovno

kopiranje podatkov z uporabo objekta DataTable ali DataReader. Podatkovni vir je lahko

skoraj vsak medij, od posredovalne podatkovne baze, XML dokumenta, pa do rezultatov

klicanja spletne službe. Zdaj, ko lahko pišemo kode za upravljanje, lahko uporabljamo

razpoložljive posebnosti v .NET Framework, da dostopamo do podatkovnega vira,

pridobivamo informacije ali obdelujemo poslovna pravila. Potem, ko smo obdelali podatke

in so le-ti nared za shranjevanje v ciljno tabelo v podatkovni bazi SQL Server, uporabimo

razred SQLBulkCopy, da podatke prenesemo na njihov cilj.

Razred SQLBulkCopy

Razred SQLBulkCopy izpostavi niz lastnosti in metod, ki nam omogočajo, da

prikrojimo opravilo masovnega kopiranja tako, da podamo informacije, kot so imena ciljnih

tabel, velikosti paketov, čas poteka strani in preslikav stolpcev.

Metode razreda SQLBulkCopy

Razred SQLBulkCopy za izvajanje opravila kopiranja zagotavlja metodo, prikazano

v naslednji tabeli. Ta metoda ima možnost prenalaganja, ki ga lahko uporabimo za obdelavo

DataReader, DataTable ali pa polja objektov DataRow.


Metoda Opis

WriteToServer (Reader) Kopira zapise iz objekta Datareader. Metoda

sprejema reference k vmesniku

IDataReader, ki omogoča, da lahko

uporabimo katerokoli podatkovni server za

izvor podatkov.

WriteToServer (Table) Kopira zapise iz objekta DataTable

WriteToServer (Table, RowState) Kopira zapise iz objekta DataTable, vendar

uporabi zapise, ki so označeni zastavico

RowState.

WriteToServer (Rows) Kopira zapise iz polja objekta DataRow.

Tabela 3.3: Metode razreda SQLBulkCopy

3.12 Navigacija spletišča

Spletne aplikacije, ki jih razvijemo, imajo običajno več kot le eno stran. Ponavadi

ustvarimo več spletnih strani, ki so na nek način povezane med seboj. Če za svoje strani

ustvarimo še navigacijo, končnemu uporabniku omogočimo uspešno delo neposredno skozi

svojo aplikacijo. Trenutno lahko izbiramo med več različnimi načini, kako končnemu

uporabniku prikazati poti skozi svojo aplikacijo. Težka stran navigacije spletišča se pokaže

takrat, ko nadaljujemo z dodajanjem strani celotni aplikaciji.

Tukajšnja metoda za izgradnjo navigacije znotraj spletnih aplikacij je, da strani

»posujemo« s hiperpovezavami. Hiperpovezave so ponavadi dodane spletnim stranem z

uporabo že vključenih datotek ali uporabniških gradnikov. Lahko so tudi neposredno fiksno

vkodirane na stran, tako da se pojavijo v glavi ali v stranski vrstici strani, ki jo trenutno

gledamo. Težave pri delu z navigacijo postanejo še hujše, ko strani premikamo ali


spreminjamo njihova imena. Včasih so razvijalci prisiljeni pregledati čisto vsako stran v

aplikaciji samo zato, da bi spremenili en aspekt navigacije.

ASP.NET se je tega problema lotil z uvedbo navigacijskega sistema, ki končnim

uporabnikom delo z aplikacijami, ki jih ustvarimo, precej olajša. Ta nova možnost v

ASP.NET je kompleksna, toda preprosta je lahko toliko, kot potrebujemo, da je, lahko pa se

dejansko poglobimo in nadzorujemo vsak aspekt njenega delovanja.

Novi navigacijski sitem vključuje možnost, da celotno stran definiramo v datoteki

XML, ki se ji reče zemljevid spletišča. Potem ko definiramo nov zemljevid spletišča, lahko z

njim razvijamo aplikacije z uporabo razreda SiteMap. Še en dodatek ASP.NET je novi

podatkovni ponudnik, ki je bil razvit posebej za delo z datotekami zemljevida spletišča in, da

jih poveže z novo serijo navigacijsko zasnovanih spletnih gradnikov.

3.12.1 SiteMap na osnovi XML

Čeprav SiteMap ni nujen element, pa je eden običajnih prvih korakov, ki jih

naredimo pri delu z novim ASP.NET 2.0 navigacijskim sistemom, da za svojo aplikacijo

ustvarimo SiteMap, ki je XML opis strukture spletne strani. Ta SiteMap uporabimo za

definiranje postavitve vseh strani v svoji aplikaciji ter to, kako se povezujejo med seboj. Če

to storimo v skladu z novim standardom za SiteMap, posredujemo te navigacijske

informacije z uporabo novega razreda SiteMap ali pa novega gradnika SiteMapDataSource.

Z uporabo SiteMapDataSource lahko informacije v datoteki zemljevida spletišča potem

povežemo z več gradniki za povezovanje podatkov, vključno z novimi navigacijskimi

spletnimi gradniki, ki jih zagotavlja ASP.NET 2.0.

Da bi ustvarili novo datoteko SiteMap za aplikacijo, svoji aplikaciji dodamo SiteMap

ali pa datoteko XML [5]. Osnovno vozlišče te XML datoteke je element <siteMapNode>. V

datoteki je lahko le en element <siteMap>. Znotraj elementa <siteMap> je še element

<siteMapNode>. To je ponavadi začetna stran aplikacije. V primeru datoteke v primeru 3.8

osnova <siteMapNode> nakazuje stran Default.aspx, začetno stran:

<siteMapNode title="Home" description="Home Page" Url="Default.aspx">

<?xml version=”1.0” encoding=”utf-8” ?>


<siteMap xmlns=”http://schemas.microsoft.com/AspNet/SiteMap-File-1.0” >

<siteMapNode title=”Home” description=”Home Page” url=”Default.aspx”>

<siteMapNode title=”News” description=”The Latest News” url=”News.aspx”>

<siteMapNode title=”U.S.” description=”U.S. News”

url=”News.aspx?cat=us” />

<siteMapNode title=”World” description=”World News”

url=”News.aspx?cat=world” />

<siteMapNode title=”Technology” description=”Technology News”

url=”News.aspx?cat=tech” />

<siteMapNode title=”Sports” description=”Sports News”

url=”News.aspx?cat=sport” />

</siteMapNode>

<siteMapNode title=”Finance” description=”The Latest Financial Information”

url=”Finance.aspx”>

<siteMapNode title=”Quotes” description=”Get the Latest Quotes”

url=”Quotes.aspx” />

<siteMapNode title=”Markets” description=”The Latest Market Information”

url=”Markets.aspx”>

<siteMapNode title=”U.S. Market Report”

description=”Looking at the U.S. Market” url=”MarketsUS.aspx” />

<siteMapNode title=”NYSE”

description=”The New York Stock Exchange” url=”NYSE.aspx” />

</siteMapNode>

<siteMapNode title=”Funds” description=”Mutual Funds”

url=”Funds.aspx” />

</siteMapNode>

<siteMapNode title=”Weather” description=”The Latest Weather”

url=”Weather.aspx” />

</siteMapNode>

</siteMap>

Primer 3.8 : Primer SiteMap


3.12.2 Spletni gradnik SiteMapPath

Uporaba datoteke s pripono »sitemap« je z uporabo spletnega gradnika SiteMapPath,

ki ga prinaša ASP.NET 2.0, precej preprosta. Ta novi gradnik najdemo v novem

navigacijskem odseku Visual Studia 2005 IDE. Gradnik SiteMapPath ustvari navigacijsko

funkcionalnost. Gradnik ustvari to, čemur nekateri pravijo drobtinska navigacija. To je

linearno definiranje, kje v navigacijski strukturi se končni uporabnik nahaja.

Namen te vrste navigacije je končnim uporabnikom pokazati, kje se nahajajo glede

na preostalo stran. Že tradicionalno je bilo kodiranje te vrste navigacije zapleteno, a zdaj bi

se z uvedbo spletnega gradnika SiteMapPath kodiranje za to vrsto spletne aplikacije moralo

zdeti mala malica.

Z gradnikom SiteMapPath je delati tako lahko, da ne potrebujemo niti podatkovnega

gradnika, da ga povežemo z datoteko Web.sitemap, kjer hrani vse svoje informacije.

Lastnost PathSeparator

Pomembna slogovna lastnost za gradnik SiteMapPath je lastnost PathSeparator. Za

ločevanje povezovalnih elementov gradnik SiteMapPath privzeto uporabi znak večje od (>).

To lahko spremenimo tako, da lastnosti PathSeparator dodelimo novo vrednost.

Z uporabo lastnosti PathSeparator ali pa elementa <PathSeparatorTemplate> je lahko

določiti, kaj želite uporabiti za ločevanje povezav v navigaciji. Gradniku SiteMapPath lahko

dodamo še vozlišče <PathSeparatorStyle>.

Lastnost PathDirection

Še ena zanimiva lastnost, ki jo uporabljamo z gradnikom SiteMapPath, je

PathDirection. Ta lastnost spremeni smer povezav, ustvarjenih v izhodu. Za to lastnost sta

možni le dve nastavitvi: RootToCurrent in CurrentToRoot . Povezava Root je prva povezava


v prikazu. To je ponavadi domača stran. Povezava Current je povezava za stran, ki je

trenutno prikazana. Ta lastnost je privzeto nastavljena na RootToCurrent.

3.12.3 Spletni gradnik Menu

Eden od zanimivejših navigacijskih gradnikov, tudi uvedenih z ASP.NET 2.0, je novi

spletni gradnik Menu. Ta gradnik je idealen za omogočanje končnemu uporabniku, da

upravlja z večjo hierarhijo možnosti, pri tem pa porablja zelo malo strežniškega prostora.

Gradnik Menu je idealen gradnik za uporabo, ko imamo veliko možnosti, pa najsi so

te možnosti izbire, ki jih ima končni uporabnik, ali pa navigacijske točke, ki jih omogoča

aplikacija, v kateri delujejo. Gradnik Menu lahko ponudi mnogo možnosti ter pri tem zasede

malo prostora. Uporaba gradnika Menu v aplikacijah je precej preprosta. Gradnik Menu

deluje z gradnikom SiteMapDataSource. Gradnika SiteMapDataSource in Menu lahko

povlečemo in spustimo na oblikovno površino Visual Studio 2005 ter oba povežemo tako, da

uporabimo lastnost DataSourceId gradnika Menu. Sicer pa ju lahko ustvarimo in povežemo

neposredno v kodi [1].

Čeprav je privzeti gradnik Menu kar preprost, lahko izgled in delovanje tega gradnika

zelo prikrojimo tako, da ponovno definiramo lastnosti gradnika.

3.12.4 Shema navigacije strani

Shema navigacije strani vsebuje naslednje elemente:

• Web.sitemap

• Other

• Data Stores Kontrolniki

• Menu

• TreeView

• SiteMapPath

• SiteMapDataSource


• SiteMap

• SiteMapNode

• XmlSiteMapProvider

• Other Site Map

• Providers

3.13 Članstvo v ASP.NET 2.0

ASP.NET 2.0 uvaja novo storitev upravljanja: avtentikacijo in avtorizacijo, ki skrbi za

prijavljanje, avtentikacijo, avtorizacijo in upravljanje z uporabniki, ki potrebujejo dostop do

spletnih strani ali aplikacij. Ta nova storitev članstva in upravljanja vlog je lahko uporabno

ogrodje, ki zunaj polja z uporabo Microsoft SQL Server deluje kot rezervna shramba

podatkov. To novo ogrodje vključuje tudi nov API, ki upošteva programski dostop do

možnosti tako storitve članstva kot upravljanja vlog. Poleg tega številni novi spletni gradniki

olajšajo ustvarjanje spletnih aplikacij, ki združujejo vse, kar imajo te storitve ponuditi.

3.13.1 ASP.NET 2.0 avtentikacija

ASP.NET 2.0 zagotavlja storitev upravljanja članstva, ki se ukvarja z avtentikacijo

uporabnikov, ki dostopajo do strani ali celotnega spletišča. Ne le, da nova ASP.NET storitev

upravljanja ponuja nov niz API za upravljanje z uporabniki, daje tudi nekaj novih spletnih

gradnikov. Ti novi spletni gradniki s končnim uporabnikom sodelujejo skozi proces

avtentikacije. ASP.NET privzeto uporabi vgrajen AspNetSQLProvider za shranjevanje

podrobnosti o registriranih uporabnikih spletne aplikacije. Tudi pri začetnih prikazih delamo

z obrazci za avtentikacijo. Predpostavimo, da je aplikacija odprta javnosti za registracijo in

ogled. Če bi bila to aplikacija na osnovi intraneta (kar pomeni, da so vsi uporabniki na

določenem omrežju), bi lahko za avtentikacijo uporabnikov uporabili Windows Integrated

Authentication [2].

ASP.NET 2.0 ponuja model podatkovnega ponudnika, ki nadzoruje podrobno

upravljanje, potrebno za sodelovanje z večimi tipi shramb podatkov, na katerih temelji.


Uporaba spletnega gradnika Login

Spletni gradnik Login omogoča, da neavtenticirane uporabnike spremenimo v

avtenticirane tako, da jim omogočimo, da podajo prijavne poverilnice, ki jih lahko preverimo

v neke vrste shrambi podatkov. V primerih smo doslej kot shrambo podatkov uporabljali

Microsoft SQL Server Express Edition, a zdaj lahko prav tako zlahka uporabimo dokončano

verzijo Microsoft SQL Serverja.

Prvi korak pri uporabi gradnika Login je, da ustvarimo novo spletno stran, recimo z

naslovom Login.aspx. To je privzeta stran, na katero so preusmerjeni neavtenticirani

uporabniki, da pridobijo svojo poverilnico. Ne pozabimo, da lahko to obnašanje spremenimo

tako, da spremenimo vrednost atributa LoginUrl elementu <forms> v datoteki Web.config.

Stran Login.aspx preprosto potrebuje gradnik <asp:Login>, da končnemu uporabniku

zagotovi vse potrebno za avtentikacijo, kot je prikazano v primeru 3.9.

<%@ Page Language=”VB” %>



<title>Login Page</title>

</head>

<body>


<asp:Login ID=”Login1” Runat=”server”>

</asp:Login>

</form>

</body>

</html>

Primer 3.9: Izvedba prijave za končnega uporabnika


3.13.2 ASP.NET 2.0 avtorizacija

Naslednji korak je avtorizacija. Kaj je avtenticiranim uporabnikom dovoljeno videti

in kakšne vloge naj prevzamejo, je pomembno vprašanje za vsako spletno aplikacijo.

Avtenticiranim uporabnikom lahko pokažemo le določene predmete, medtem ko

neavtenticiranim uporabnikom lahko pokažemo drugačne predmete [1].

Uporaba spletnega gradnika LoginView

Spletni gradnik LoginView nam omogoča, da nadzorujemo, kdo gleda katere

informacije na določenem delu strani. Z uporabo gradnika LoginView lahko narekujemo,

kateri deli strani so za avtenticirane uporabnike in kateri deli za neavtenticirane uporabnike.

3.14 Spletni gradniki (WebParts)

Da lažje obdržimo nastavitve strani po meri, ki jih končni uporabniki uporabljajo na

naši strani, je Microsoft v to izdajo ASP.NET vključil spletne gradnike. Spletni gradniki, ki

so del večjega portala Framework, zagotavljajo izjemen način ustvarjanja modularnega

spletnega mesta, ki ga lahko prilagodimo z dinamično ponovno uporabljenimi nastavitvami

na uporabniku prijazni osnovi. Spletni gradniki so objekti v Framework, ki jih uporabnik

lahko odpre, zapre, pomanjša, poveča ali premakne iz enega dela strani v drugega.

Portal Framework nam omogoča ustvarjanje strani, ki vsebujejo več spletnih

gradnikov, ki so del ASP.NET spletno-gradniškega ogrodja in se uporabljajo kot vsak drug

ASP.NET spletni gradnik. To pomeni, da spletne gradnike lahko po potrebi razširimo [1].

Komponente Portal Framework zagotavljajo sredstva za izgradnjo res dinamičnega

spletnega mesta, pa naj je to tradicionalno internetno spletišče, intranetno spletišče,

aplikacija na osnovi brskalnika ali katerikoli drug tipični portal. Ko prvič pogledamo spletne

gradnike v ASP.NET 2.0, nas bodo morda spomnili na Microsoftovo ponudbo SharePoint.

Toda ti dve tehnologiji nista enaki. Ekipa ASP.NET je uvedla spletne gradnike; Portal

Framework, ki je rezultat tega, uporablja poleg tega, da ga ponuja ASP.NET, tudi Windows

Share Point Services (WSS). Microsoft, tako kot ponavadi, ustvarja preprosto edinstvene


tehnologije, ki jih lahko uporabljamo tudi v drugih Microsoft ponudbah. Pri tem Microsoft

skuša doseči Sveti Gral računalništva – ponovno uporabo kod!

Modularna in prilagodljiva spletišča, ki jih lahko ustvarjamo z novim Portal Framework,

omogočajo, da spletno stran, ki je na vidiku, damo v več možnih načinov za končnega

uporabnika. Naslednji seznam opisuje vsakega od razpoložljivih načinov in kaj vsak od njih

pomeni za končnega uporabnika, ki si stran ogleduje:

• Normal Mode: stran postavi v normalno stanje, kar pomeni, da končni uporabnik

odsekov strani ne more urejati ali premikati. To je način, ki se uporablja za

standardno ogledovanje strani.

• Edit Mode: končnim uporabnikom omogoča, da za urejanje izberejo posebne odseke

na strani. Izbran odsek dovoljuje vse vrste možnosti urejanja od spreminjanja

gradnikovega imena, barve ali celo nastavljanja lastnosti po meri: od omogočanja

končnemu uporabniku, da poda svojo poštno številko, pa vse do nalaganja vremenske

napovedi po meri.

• Design Mode: končnim uporabnikom omogoča preureditev vrstnega reda modularnih

komponent strani. Končni uporabnik lahko v nekem omrežju predmete premakne

više ali niže, briše predmete iz območja ali pa premakne predmete iz enega območja

strani v drugega.

• Catalog Mode: prikaže seznam razpoložljivih odsekov (spletnih gradnikov), ki jih

lahko damo na stran. Catalog Mode omogoča končnemu uporabniku tudi, da si

izbere, v katerem območju na strani naj se predmeti pojavijo.

3.14.1 Gradniki za delo s spletnimi gradniki

Potem ko damo na stran gradnik WebPartManager, je naslednji korak, da ustvarimo

območja, v katerih lahko uporabljamo Portal Framework. Ta korak bi morali malce

premisliti, saj prispeva neposredno k funkcionalnosti strani, ki jo ustvarjamo. Spletne strani

se izgrajujejo linearno – pa najsi horizontalno ali vertikalno. Upravljamo jih v kvadratnih

poljih – ponavadi z uporabo tabel, ki urejajo stolpce in vrstice, v katerih se na strani

pojavljajo predmeti.


Spletna območja definirajo posebne vrstice ali stolpce kot ločena vsebinska področja,

ki jih upravlja WebPartManager. Slika 3.7 ponazarja spletne gradnike.

Slika 3.7: Spletni gradniki

3.15 Predpomnjenje

Pri ASP.NET 1.0/1.1 in zdaj v ASP.NET 2.0 se razvijalci s predpomnjenjem

spopadamo na več načinov. Prvič, predshranimo lahko celoten HTTP odgovor (celotno

spletno stran) z uporabo mehanizma, ki se mu reče izhodno predpomnjenje. Dve drugi

metodi sta delno predpomnjenje strani in predpomnjenje podatkov. Naslednji odseki

opisujejo te metode.

Mnogi podatkovni izvori imajo vgrajeno podporo za predpomnjenje:


• EnableCaching – vklop/izklop predpomnjenja

• CacheDuration – trajanje predpomnilnika

• CacheExpirationPolicy – Sliding/Absolute

• CacheKeyDependency/SQLCacheDepedency – invalidacija predpomnilnika

• Predpomnjenje brez pisanja kode.

3.16 Ostale novosti

• SQLCacheDependency

• Lokalizacija

• Nov model prevajanja in nameščanja strani

• Asinhrono osveževanje strani (Client Script Callback)

3.17 Novosti v ASP.NET 3.5

19. novembra 2007 je Microsoft uradno izdal ASP.NET verzijo 3.5 in Visual Studio

2008. Kakor pri napredku od ASP.NET 2.0 na 3.0, so značilnosti pri ASP.NET 3.5

dodajalne, kar pomeni, da osnovne programske komponente, nameščene v .NET Framework

verziji 2.0, še zmeraj uporabljata tudi verziji 3.0 in 3.5. Skratka, ASP.NET 3.5 ne spreminja,

odvzame ali ukinja nobene funkcionalnosti, koncepta ali kode, ki je bila prisotna v 2.0 –

ogrodju preprosto doda nove tipe in značilnosti ter zmožnosti [18].

Visual Studio 2008 je priporočljivo orodje za razvijanje ASP.NET aplikacij. Za

razliko od prejšnjih verzij Visual Studio, ki so bile namenjene specifični verziji ogrodja (t.j.,

Visual Studio.NET 2003 je bil namenjen ASP.NET 1.1, Visual Studio 2005 pa ASP.NET

2.0), je Visual Studio 2008 večnamenski, kar pomeni, da iz spustnega seznama izbiramo, ali

naj Visual Studio 2008 izgradi aplikacijo z ogrodjem ASP.NET 2.0, 3.0 ali 3.5. Visual

Studio 2008 vključuje tudi izboljšano oblikovalsko izkušnjo, odpravljanje napak pri


JavaScript ter značilnosti IntelliSense, pa tudi možnost pregleda in celo dostopa do jedra

kode .NET Framework med odpravljanjem napak.

ASP.NET AJAX

Z ASP.NET AJAX razvijalci lahko hitro ustvarjajo strani z visoko razvitimi,

odzivnimi uporabniškimi vmesniki ter z bolj učinkovito komunikacijo odjemalec-strežnik,

preprosto z dodajanjem nekaj strežniških gradnikov svojim stranem. Prej samo razširitev pri

ASP.NET trajanju izvajanja, je ASP.NET AJAX zdaj vgrajen v računalniško okolje in olajša

zapleteno nalogo izgrajevanja standardnih AJAX aplikacij v različnih računalniških okoljih.

Nova gradnika ListView in DataPager

Novi gradnik ListView nam pri prikazovanju podatkov daje neomejeno fleksibilnost,

saj nam omogoča popoln nadzor nad ustvarjenimi HTML oznakami. Pristop Listview

predlog za predstavitev podatkov je oblikovan tako, da zlahka delamo s CSS slogi, kar je

priročno v novem oblikovalskem pogledu Visual Studio 2008. Poleg tega lahko gradnik

DataPager uporabimo za obvladovanje dela, ki nastane zaradi dovoljevanja našim

uporabnikom, da listajo po veliki količini zapisov.

LINQ in druge .NET Framework 3.5 izboljšave

Z dodatkom Language Integrated Query (LINQ) v .NET Framework 3.5 je proces

izgradnje SQL poizvedb z uporabo manipulacije niza, kjer pa se rade pojavljajo napake, zdaj

preteklost. LINQ naredi naše poizvedbe o relacijskih podatkih v C# in Visual Basic

prvovrstni jezikovni konstrukt, ki ga dopolnjuje podpora prevajalniku in Intellisense. Za

spletne aplikacije nam gradnik ASP.NET LinqDataSource omogoča preprosto uporabljati

LINQ za filtriranje, naročanje in grupiranje podatkov, ki jih potem lahko povežemo s

katerimkoli gradnikom za vizualizacijo podatkov, kot sta gradnika Listview in GridView. Še

več, vse druge izboljšave .NET Framework 3.5, vključno z zbirko HashSet, DateTime


podporo za odmike, diagnostiko, sproščanje pomnilnika, boljša podpora za omejevanje niti

in drugo, so nam na voljo v ASP.NET aplikacijah [16].

WCF podpora za RSS, JSON, POX in delne poverilnice

S .NET Framework 3.5 zdaj Windows Communication Foundation (WCF) podpira

izgrajevanje spletnih storitev, ki jih lahko razkrijemo z uporabo katerekoli številke protokola

internetnega standarda, kot so SOAP, RSS, JSON, POX in drugi. Če izgrajujemo AJAX

aplikacijo, ki uporablja JSON, kateri omogoča ponudbo naših podatkov preko RSS, ali če

izgrajujemo standardno spletno storitev SOAP, WCF olajša ustvarjanje naših končnih točk,

zdaj, z .NET Framework 3.5, pa še podpira izgrajevanje spletnih storitev v situacijah delnega

zaupanja, kot je tipično okolje s skupnim gostovanjem.

3.18 Novosti v Visual Studio 2008

Kaj nam omogoča?

• Delo v različnih verzijah ogrodja .NET

• Poenostavljeno delo s programsko kodo

• Bogatejšo izkušnjo z gradnjo spletnih strani z novim izpopolnjenim

urejevalnikom

• Nadzor in testiranje zgrajenih aplikacij

• Izboljša sodelovanje med razvijalci in oblikovalci

• Hitrejši in enostavnejši razvoj aplikacij

Delo s programsko kodo

Omogoča nam poenostavljeno delo s programsko kodo. Vsebuje podporo LINQ,

podpira okolje za hitrejši dostop do informacij. Vsebuje izboljšan Intellisense, refactoring in

razhroščevalnik. Slika 3.8 nam prikazuje pregled programskiga okolja [17].


Slika 3.8 : Pregled programskega okolja

Gradnja spletnih strani

Razvijalsko orodje za razvoj spletnih strani vsebuje naslednje novosti:

• Izboljšan urejevalnik spletnih strani • Razdeljeni pogled • Oblikovni vpogled gnezdenih predlog strani • Izboljšan css urejevalnik • Manage Styles, css properties • Novi gradniki (odvisno od verzije ogrodja) • Javascript razhroščevalnik

ASP.NET 2.0 in ATLAS 55

4. ASP.NET 2.0 in ATLAS

4.1 Kaj je Atlas?

Razvijalci so se dolgo spoprijemali z jezikom HTML, s snovanjemm uporabniških

vmesnikov, z zapletenostjo skript, implementiranih v jeziku JavaScript, in z drugimi

združljivimi brskalniki. V zadnjih nekaj letih so nove zmogljivosti v brskalnikih opogumile

spletne razvijalce, da znova osvojijo možnosti izdelovanja na odjemalcu temelječe

aplikacije. Vsi priljubljeni brskalniki podpirajo dokumentni objektni model (DOM), zadnjih

nekaj različic teh brskalnikov pa je dodalo zmožnosti neposrednega komuniciranja med

odjemalcem in strežnikom, brez prenosa zahtev in odgovorov. Rezultat je nova generacija

spletnih aplikacij, kot je Microsoft Virtual Earth in Microsoft Windows Live, ki so odzivne

in zagotavljajo značilnosti uporabniškega vmesnika, kot so »povleci in spusti«, ter

procesirajo podatke v realnem času.

Pri razvoju teh aplikacij pa nastane problem, ki ni enostaven. Razvijalec mora kodirati

programsko kodo v jeziku JavaScript in razumeti implementacijo dokumentnega objektnega

modela, ki se od brskalnika do brskalnika razlikuje.

Tukaj pa nastopi ASP.NET Atlas. Atlas je nova ASP.NET spletna tehnologija , ki

vključuje knjižnice odjemalčevih skript (client script libraries), temelječih na ASP.NET 2.0

razvijalskem ogrodju. Atlas nudi razvijalska računalniška okolja za spletne strani, ki

temeljijo na odjemalcu, kot jih ASP.NET nudi za strežniško temelječe strani. Atlas je

nadgradnja ASP.NET. Pri uporabi Atlasa lahko premikamo ogromne deleže aplikacijskih

procesov k odjemalcu, pri tem pa ohranimo možnost komuniciranja s strežnikom v ozadju.

Rezultat tega je, da lahko ustvarimo strani s končnico »aspx« z bogatim uporabniškim

vmesnikom in strežniško komunikacijo. Atlas nam omogoča, da zlahka prevzamemo tehnike

AJAX tehnologije ter ustvarjanje strani s končnico »aspx« z bogatim uporabniškim

vmesnikom [8].


4.2 Kaj nudi Atlas?

Primarni cilj Atlasa je integracija značilnosti odjemalčevih script z značilnostmi

tehnologije ASP.NET na strežniku, da se tako zagotovi obširno razvijalsko računalniško

okolje.

Značilnosti odjemalca

Pri razvijanju spletnih strani Atlas upravlja kompleksnost razvijanja, ki temelji na

programskem jeziku JavaScript in nudi naslednje razvijalske značilnosti:

• Kompatibilnost z brskalnikom tako, da ni potrebno posebno kodiranje, da bi

omogočili zagon aplikacij v več brskalnikih.

• Odjemalčeve skripte in komponente, ki podpirajo bogate značilnosti uporabniškega

vmesnika, kot je obnašanje »povleci ali spusti«.

• Deklarativni model ravijanja odjemalca, ki je podoben deklarativni sintaksi

strežnikove kontrole ASP.NET.

Značilnost strežnika

Atlas integrira odjemalčeve skripte z razvojem ASP.NET strežnikove strani, da lahko

upravljamo opravila aplikacij tam, kjer je to najbolj smiselno. Tehnologija ASP.NET nudi

naslednje strežniške značilnosti:

• Spletne storitve, ki so zelo uporabne pri integraciji z aplikacijami Atlas, kot npr.

storitveni profili.

• ASP.NET spletni gradniki, ki avtomatično oddajajo vse odjemalčeve skripte,

potrebne za Atlas aplikacije, tako, da v programskem jeziku JavaScript ni

potrebno kodirati.

• Integrirana razvijalska orodja Visual Studio za razvijanje odjemalčeve strani, ki

nam omogočajo razhroščevanje.


4.3 Spletni gradniki ASP.NET Atlas

Ogrodje ASP.NET Atlas nam dopušča razvijanje bogatih uporabniških vmesnikov z

uporabo odjemalčevih gradnikov in komponent v deklarativni ali programerski obliki.

Podobne odjemalčeve funkcionalnosti lahko dodajamo k novim ali obstoječim ASP.NET

aplikacijam z uporabo ASP.NET Atlas strežniškega gradnika. Kar lahko delamo, je sledeče:

• Izberemo izvajanje delnih strani, namesto normalnega posredovanja zahtev z

uporabo gradnika UpdatePanel

• Uporabimo razširitev gradnika za dodajanje prej omenjenega obnašanja

odjemalca k ASP.NET gradnikom, kot je npr. dodajanje obnašanja

avtomatskega dokončanja k gradniku TextBox.

• Ustvarjamo poljubne razširitve, ki definirajo nova obnašanja strežniških

gradnikov. Razvijalci strani lahko potem dodajajo razširitve k strežniškim

gradnikom in dobijo obnašanje odjemalca brez pisanja ASP.NET Atlas skript.

Gradnik UpdatePanel

Kadar se pojavi posredovanje zahtev v tipičnih ASP.NET 2.0 aplikacijah, se stran

znova izvede. To nam povzroči, da stran v brskalniku začne utripati. V času posredovanja

zahtev se na strežniku izvede celoten življenski cikel strani. To končno sproži dogodek

gradnika, ki je sprožil posredovanje zahtev, da zažene obravnavo dogodka (npr. dogodek

klik na gumb).

Gradnik UpdatePanel nam omogoča delno osveževanje strani in gradnikov, tako da

stran ne utripa.

Vsebuje naslednje lastnosti:

• Samodejno prevede povratni odgovor v asinhrone povratne klice

• Samodejno osveži vsebino po povratnem klicu


• Ne zahteva poznavanja JavaScript ali XmlHttp

• Omogoča enostavno definiranje regij spletne strani za osveževanje

• Asinhroni dostop do osveženih podatkov na strežniku

• ASP.NET AJAX poskrbi za vso potrebno infrastrukturo

• Na eni spletni strani lahko imate poljubno število UpdatePanel gradnikov

Primer 4.1 demostrira uporabo gradnika UpdatePanel:

<atlas:ScriptManager runat="server" ID="ScriptMgr" EnablePartialRendering="true">

..

</ScriptManager>

<atlas:UpdatePanel runat="server" ID="UpdatePanel2" Mode="Always">

<ContentTemplate>

<asp:label runat="server" Text="Keep changing me!" ID="Label1" />

..

</ContentTemplate>

..

</atlas:UpdatePanel>

Primer 4.1: Gradnik UpdatePanel

Gradnik UpdatePanel zahteva gradnik ScriptManager, ki je odgovoren za

ustvarjanje relevantnih ASP.NET Atlas referenčnih skript v odjemalcu in za upravljanje

delnega napravljenega modela. Gradnik ScriptManager upravlja delne spremembe strani in

dopušča samo izvajanje gradnika UpdatePanel.

Gradnik ScriptManager

• Ključna komponenta v ASP.NET AJAX

• Na strani je potreben, da deluje AJAX, en primerek ScriptManager

• Registrira AJAX Client Library

• Omogoča delno osveževanje strani (UpdatePanel)


• Lahko ga uporabimo za registracijo lastnih skript

• Skrbi za asihrono komunikacijo med odjemalcem in strežnikom

• Script Reference

• Za spletne storitve generira JS Proxy razrede

• Service Reference

Triggers

• Vsi gradniki znotraj enega UpdatePanela povzročijo osveževanje vsebine le tega (če

so razlog za povratni odgovor in je lastnost ChildrenAsTriggers = true)

• Eksplicitno pa lahko določimo, da dogodek na poljubnem gradniku na spletni strani

povzroči osvežitev določenega UpdatePanela s pomočjo prožilca:

<asp:AsyncPostBackTrigger>

• V kodi lahko poljuben gradnik registriramo za asinhroni povratni odgovor s pomočjo

klica z metodo RegisterAsyncPostBackControl na ScriptManagerju

UpdateProgress

• Namenjen predvsem prikazovanju teksta med asihronim osveževanjem strani

• Uporabimo lahko tudi druge elemente, kot npr. sliko, film, “karkoli”...

4.4 Ogrodje Atlas – AJAX

Nova ASP.NET tehnologija, poimenovana Atlas, je paket Microsoftove tehnologije, ki

uporablja in razširja pristop AJAX.


4.5 Tehnični koncepti AJAX

Pri AJAX lahko razvijalci kličemo spletne storitve asinhrono od odjemalčevih skript z

uporabo objekta XmlHttpRequest, s katerim zapakiramo informacije kot XML podatke in jih

nato preusmerimo v omrežje. Da lahko kličemo, nam objekt XmlHttpRequest priskrbi

nadomestni objekt, ki naredi oddaljen klic in sprejema ter pošilja podatke [11].

AJAX poleg tega omogoča razširjeno uporabo skripte odjemalčeve strani, podobno

Java Script (ECMAScript). JavaScript se uporablja za izvedbo oddaljenih procedurnih

klicev, za izvedbo aplikacijskih procesov na odjemalcu (obratno od obravnave na strežniku)

in za ustvarjanje izboljšanih značilnosti uporabniškega vmesnika.

AJAX rešitve nudijo programski jezik JavaScript skupaj z nekaj drugimi

odjemalčevimi tehnologijami, vključujoč naslednje:

• Dinamični HTML, ki nadgradi HTML s pripomočki za odziv na uporabnikov vhod

na strani v odjemalčevi skripti, brez opravljanja obhoda strani.

• Komponente, ki so objekti jezika JavaScript po želji ter omogočajo razširjene

odjemalčeve UI značilnosti.

XAML 61

5. XAML

5.1 Kaj je XAML?

XAML je nov na XML temelječ deklarativni označevalni jezik za razvoj

uporabniškega vmesnika. XAML, razširjen aplikacijski označevalni jezik, je Microsoft razvil

za hitro gradnjo uporabniškega vmesnika za aplikacije .NET ogrodja. Longhorn, naslednja

verzija operacijskega sistema Windows, je ustvarjena za ločevanje predstavitvene plasti od

aplikacijske logike. XAML je za Longhorn privzeti jezik za programiranje uporabniškega

vmesnika.

XAML dopušča razvijalcu nadzor nad aplikacijskim vmesnikom, vključno s tekstom,

grafiko, gumbi in celotno zbirko gradnikov .NET uporabniškega vmesnika. Vsaka XAML

oznaka ustreza neposredno razredu .NET ogrodja. Tako je npr. ustvarjanje novega gumba

tako preprosto kot uporaba <Button> oznake v naši XAML datoteki. Oznaka instancira

gumbov objekt z uporabo privzetega gradnika in nam dopušča nastavljanje lastnosti

gumbovega objekta, kot je npr. tekstovna oznaka. Dogodki in z njimi povezana obravnava

kode v ozadju (code behind) so v XAML določeni kot atributi. V Longhorn je lahko koda

napisana v XAML datoteki ali pa vstavljena v kodi v ozadju v datoteki, podobno kot

ASP.NET.

S XAML kot predstavitveno plastjo in .NET jezikom kot logično plastjo obravnave

dogodkov, lahko gradimo trpežne aplikacije, ki se lahko zlahka nadgrajujejo in spreminjajo,

brez križanja linije med predstavitvijo in logiko. Uporabniški vmesnik se zlahka spreminja,

ne da bi posegali v logiko in kodo obravnave dogodkov, kar poenostavi razvijanje in naredi

aplikacijsko kodo bolj varno [8].

5.2 XAML in objekti

Vsak element v XAML datoteki ima za rezultat odgovarjajoč objekt, ki se je ustvaril ob

času izvajanja. Ti razredi so del razrednih knjižnic Avalon.

XAML 62

XAML imenski prostor je prepoznan od XAML prevajalnika, kar pomeni, da se morajo

uporabiti razredi iz knjižnic Avalon. Prav tako lahko definiramo poljubne imenske prostore

za uporabo razrednih knjižnic. Pravzaprav lahko uporabimo katerikoli .NET razred XAML.

XAML datoteke so ob času izvajanja navadno prej prevedene kot pa razčlenjene. Ko

gradimo na XAML temelječ projekt, XAML prevajalnik generira razred za vsako XAML

datoteko. Ti razredi vsebujejo kodo za ustvarjanje objektov, določenih v XAML.

Z uporabo Longhorn – omogočeno verzijo Visual Studia .NET Whidbey, ki je bila

izdana leta 2003 na konferenci PDC (Professional Developers Conference), lahko

uporabljamo eno izmed Longhorn aplikacijskih predlog za ustvarjanje novega na XAML

temelječega projekta. Ko prevedemo projekt, XAML prevajalnik zgenerira začasno izvorno

kodo za vsako XAML datoteko. Te datoteke so ustvarjene v obj/Debug ali obj/Release

poddirektorijih. Če je npr. XAML v primeru zgoraj vstavljen v datoteko z imenom

MyPanel.xaml, nam izgradnja projekta povzroči nastanek začasne datoteke

obj/Debug/MyPanel.g.cs. (če uporabljamo Visual Basic .NET, bo končnica datoteke »vb«

namesto »cs«).

Če pogledamo notranjost te zgenerirane datoteke, bomo našli definicijo razreda. Za vsako

XAML datoteko nam XAML prevajalnik izgradi razred, ki izhaja iz razreda za korenski

element XML dokumenta [9].

5.3 Lastnosti XAML

Prav tako kot ustvarjanje objektov nam XAML dopušča tudi nastavljanje lastnosti

objektov. Primer 5.1 ponazarja, na kak način spremenimo vrstico, ki ustvari gumb.

<Button Background="Red">Klikni me</Button>

Primer 5.1: Ustvarjanje Button

To nam nakazuje, da mora biti nastavljena gumbova lastnost za ozadje. XAML

prevajalnik zgenerira potrebno kodo za nastavitev lastnosti, kot nam prikazuje primer 5.2.

XAML 63

Button_3_.Background =

new MSAvalon.Windows.Media.SolidColorBrush(

MSAvalon.Windows.Media.Color.FromARGB(255, 255, 0, 0));

Primer 5.2: Lastnost gradnika Button

Definicija XAML aplikacij

XAML aplikacijo tvorita dve vrsti elementov: aplikacijski element in nabor

elementov, ki sestavljajo uporabniški vmesnik. XAML datoteke vsebujejo definicijo

uporabniškega vmesnika za vašo aplikacijo. Datoteke s kodo v ozadju bodo vsebovale

aplikacijsko logiko in kodo, ki upravlja procesiranje dogodkov. XAML ne nudi mehanizma

za upravljanje dogodkov, a lahko usmeri krmilnik izvajanja, da prikliče upravljalce

dogodkov, napisane v C# ali v VB.NET. Če smo razvijalci, bomo kodirali upravljalnike

dogodkov in aplikacijsko logiko enako kot vedno, a ker je koda za uporabniški vmesnik

ločena, bomo morali biti malce bolj pozorni na imena upravljalnikov in elementov, na katere

se sklicujemo, saj jih ne določamo sami, temveč so le-ti že navedeni in poimenovani v

XAML datoteki.

Najbolj pogost aplikacijski element je tipa NavigationApplication.

NavigationApplication definira aplikacijo, ki se vede kot spletna aplikacija ali kot čarovnik,

v katerem sestoji iz strani, med katerimi uporabnik krmari z uporabo hiperpovezav ter

gumbov naprej in nazaj.

Definicija aplikacije je ponavadi podana v njeni lastni datoteki. Zahteva, da

določimo dve lastnosti, imenski prostor in zagonski URI, ki je URI prve strani, ki naj se

naloži, ko se aplikacija zažene.

V XAML imena elementov odgovarjajo CLR objektnim imenom, atributi pa

predstavljajo lastnosti. Izjema temu pravilu so standardni XML elementi, kot je na primer

xmlns, ki se uporablja za podajanje imenskega prostora, ki je uporabljen v XML datoteki.

Imenski prostor, ki smo ga uporabili tu, je privzet imenski prostor aplikacije in določa

Avalon tipe. Če kot privzetega nismo določili Avalon imenskega prostora, bi morali vsi

jedrni XAML elementi vsebovati sklic nanj. To pa pomeni veliko dodatnega tipkanja.

XAML 64

Veliko laže je za privzet imenski prostor uporabiti Avalon, razen če bomo

prednostno uporabljali elemente po meri, določene v našem lastnem imenskem prostoru, a v

tem primeru je verjetno lažje določiti kot privzet naš lasten imenski prostor ter namesto tega

izrecno določiti XAML elemente. Vsak XAML element zahteva ali izrecni sklic na imenski

prostor na osnovi posameznega elementa ali pa določitev imenskega prostora Avalon kot

privzetega za korenski element. Seveda je priporočljivo slednje, saj bo zahteve zmanjšalo

tako, da se bo za vsak XAML element v datoteki izrecno sklicevalo na imenski prostor. Prvi

element, ki je podan v vsaki XAML datoteki, se imenuje korenski element. Le-ta mora

vsebovati sklic na imenski prostor, v katerem je definiran. Pri XAML elementih je imenski

prostor »http://schemas.microsoft.com/winfx/avalon/2005« [13].

Korenski elementi so vsebniki, ki vsebujejo druge XAML elemente. Najbolj pogost

korenski element za definicijo aplikacije je NavigationWindow. Najpogostejši korenski

elementi za definicijo strani so Panel in njegove podvrste, DockPanel, StackPanel in Page.

Uporablja se tudi Window, vendar pa ne tako pogosto kot prej omenjeni elementi.

Primer 5.3 vsebuje dejansko definicijo uporabniškega vmesnika. Vsaka naslednja

stran bo preusmerjena preko mehanizmov dovoljevanja, kot je na primer element

HyperLink. Kot vse XAML datoteke tudi stran1.xaml zahteva korenski element. Datoteka je

prikazana v primeru 2.

<StackPanel xmlns="http://schemas.microsoft.com/winfx/avalon/2005">

<TextBlock>Zdravo Svet</TextBlock>

<Button Width="100">Klikni me</Button>

</StackPanel>

Primer 5.3: korenski element XAML datoteke

Element TextBlock vsebuje tekst, element Button pa predstavlja standardni gumb

uporabniškega vmesnika. Interpretacija kode v XamlPad vrne izložek. To je izredno preprost

primer XAML aplikacije, pri kateri se ni popolnoma nič pazilo na slog, izgled ali

uporabnost. V datoteki so podane minimalne zahteve za XAML aplikacijo. Ko bo uspešno

definirana aplikacijska definicija (MyApp.xaml) in definicija strani (stran1.xaml), bo čas za

izgraditev aplikacije v izvršljivo Windows datoteko.

XAML 65

5.4 Razvoj XAML aplikacij

Medtem ko XAML lahko uporabimo za ustvarjanje knjižnic in modulov, ki jih je

mogoče deliti ter uporabiti za razvoj drugih aplikacij (na enak način kot lahko za razvoj DLL

ali deljenih programskih komponent uporabimo C# ali VB.NET), pa je bolj verjetno, da

boste XAML uporabili za ustvarjanje neke aplikacije. Obstajata dve vrsti XAML aplikacij:

hitre in namestitvene. Express applications so klasične namizne aplikacije in so lahko ali

Windows aplikacije ali pa konzolne aplikacije. Vrsto aplikacije, ki jo ustvarjamo, določimo z

vrednostjo lastnosti v projektni datoteki, ki jo MSBuild uporablja, da zbere aplikacijo.

MSBuild je ena novih funkcij v Windows Vista in Visual Studio 2005. Ob izdaji

Visual Studio 2005 se je Microsoft usmeril k poenotenemu okolju za izgradnjo. Vsi projekti

za ustvarjanje CLR zbirnikov sedaj uporabljajo MSBuild pripomočke. Najbolj vznemirljiv,

pa tudi koristen vidik te spremembe je, da za prevajanje in razvoj aplikacij ni več potreben

Visual Studio; izgradnjo brez njega lahko popolnoma avtomatiziramo.

XAML aplikacije in Visual Studio

Pri delu z Visual Studio lahko izbiramo med precej WinFX aplikacijami, projektne

datoteke in prikaz aplikacije pa bodo ustvarjene samodejno. Lahko ustvarjamo izvršljivi

WinFX Windows, WinFX WebBrowser aplikacijo, WinFX Service knjižnico (ki ustvari

WinFX knjižnico, ki vsebuje definicijo in uvedbo WinFX Service) ali pa WinFX knjižnico s

prirejenimi ukazi (za razširitev WinFX ukazov). Še vedno pa moramo ročno urejati XAML

in z njim povezane C# ali VB.NET kodo v ozadju datoteke.

Če smo si prenesli in namestili WinFX razširitve za Visual Studio 2005, zaženemo

IDE. Izberemo Create Project in pokaže se nam seznam možnosti, kot prikazuje slika 5.1.

XAML 66

Slika 5.1. Možnosti WinFX aplikacije v Visual Studio 2005

Sintaksa XAML jedra

XAML ponavadi uporablja XML pravila sintakse, enako kot vsak drugi

označevalni jezik na osnovi XML. Vsak XAML element ima ime in enega ali več atributov.

Atributi se neposredno ujemajo z lastnostmi objektov, ime vsakega XAML elementa pa se

natanko ujema z imenom CLR definicije razreda.

XAML je čisti označevalnik, kar pomeni, da je treba, medtem ko so imena

upravljalcev dogodkov podana kot atributi, vnesti dejansko logiko upravljalca dogodkov v

kodo. Izvedeni so lahko ali v C# ali pa v VB.NET. V obeh primerih lahko kodo vstavimo v

vrstico v XAML datoteki, pa čeprav je to v nasprotju z najboljšim načinom, kako ločiti obe

ravni, predstavitev in aplikacijsko logiko. Vsakemu elementu v XAML lahko dodelimo

upravljalca s kodo v ozadju, ki je lahko izveden v podprtem .NET jeziku.

XAML 67

Elementi

Vsi XAML elementi so XML predstavite CLR razredov, a vsi CLR razredi niso

predstavljeni v XAML. Večina predstavljenih elementov uporabniškega vmesnika je konec

koncev izpeljanih iz System.Windows.UIElement, ki nudi lastnosti osnovnega vizualnega

uporabniškega vmesnika, ki so skupne večini XAML elementov.

System.Windows.UIElement se je sposoben prikazovati, sprejemati vnose preko tipkovnice

in miške, vizualno razporejati po velikosti in razporediti svoje podrejene elemente ter javljati

dogodke .

Večino XAML elementov lahko razdelimo na pet osnovnih kategorij:

• Korenski elementi

• Nadzorni elementi

• Ploščni elementi

• Oblikovni in geometrični elementi

• Elementi dokumentov

Korenski elementi

Korenski elementi delujejo kot osnovni vsebnik strani za vse elemente

uporabniškega vmesnika. Stran mora imeti en korenski element. Najširše uporabljani

korenski elementi so ploščni elementi StackPanel, DockPanel, Canvas in Gridand Page,

korenski element, ki nam omogoča deklarativni nadzor količine lastnosti okna, ki vsebuje

XAML stran. Da se neki element smatra kot korenski, mora biti vsebnik za vsaj en element.

(Ob prikazu XAML izložka v XamlPad nam ni potrebno vključiti korenskega elementa, saj

nam ga priskrbi XamlPad.) Korenske elemente po meri lahko ustvarimo tako, da iz Page ali

Window izpeljemo nove razrede in jih potem prikažemo kot XAML elemente.

XAML 68

5.4.1 Nadzorni elementi

Nadzorni elementi so zadolženi za interakcijo z uporabnikom. Gradniki so

interaktivni in uporabniku omogočajo vnašanje podatkov, izbiranje ter izvajanje drugih

interaktivnih opravil. Lahko jih razbijemo na pet kategorij: preprosti gradniki, vsebinski

gradniki, predmetni gradniki, headerski predmetni gradniki ter headerski vsebinski gradniki.

Razlikujejo se po atributih, ki jih podpirajo, in sicer Content, Headers in Items.

Kateri atribut podpirajo, določa temeljni CLR razred, ki ga predstavlja XAML element. Celo

če ne uporabimo atributa Header, ki bi ga podpiral headerski predmetni gradnik, ne postane

predmetni gradnik, saj ima CLR razred, katerega predstavlja, še vedno Header, pa najsi mu

dodelimo vrednost ali ne.

Preprosti gradniki

Izhajajo neposredno iz razreda System.Windows.Control in nimajo atributov

Content, Items ali Header. Primeri preprostih gradnikov so HorizontalScrollBar,

VerticalScrollBar, Frame, TextBox, and RichTextBox.

Vsebinski gradniki

Imajo atribut Content, ne pa tudi atributov Items ali Header. Vsebina gradnikov

Content je omejena na en element, pa čeprav je lahko ta vsebina tudi element (na primer

Panel), ki lahko vsebuje več kot en element. Primeri vsebinskih gradnikov so: Button,

RepeatButton, Label, RadioButton, CheckBox, ListBoxItem, GroupItem, StatusBarItem,

ToolTip, ScrollViewer in Window.

Predmetni gradniki

Imajo atribut Items, ne pa tudi atributov Header ali Content. Predmetni gradniki

prikažejo seznam elementov, ki nam ponavadi daje možnost izbire. Predmetni gradniki

vključujejo ListBox, ComboBox, Menu, ContextMenu, RadioButtonList in TabControl.

XAML 69

5.4.2 Ploščni elementi

Ploščni elementi urejajo postavitev strani in delujejo kot vsebniki za elemente, kot so

gradniki ali druge plošče. Nekateri iz plošče izhajajoči elementi se uporabljajo kot korenski

elementi, toda glavni namen plošče je zagotavljati podporo ureditvi in postavitvi elementov

na strani. Nekateri razredi plošče so namenjeni oblikovanju uporabniškega vmesnika,

medtem ko so drugi posebne plošče, oblikovane predvsem za posebne scenarije ureditve.

Tak primer je Bullet Panel, ki se uporablja samo za prikaz dveh podrejenih elementov

(ponavadi tekstovnega elementa in glifa, ki predstavlja potrditveno okence ali radijski

gumb), pa tudi kot komponenta drugih elementov, kot sta na primer RadioButton in

CheckBox. Ko navedemo RadioButton, je BulletPanel ena temeljnih komponent, ki se

prikažejo na zaslonu.

Ploščni elementi, namenjeni za oblikovanje uporabniškega vmesnika, so DockPanel,

StackPanel, Canvas, WrapPanel in Grid.

5.4.3 Razporeditev in postavitev

StackPanel

Privzeto samodejno podaja elemente v vrstnem redu, v kakršnem so podani v XAML

datoteki, od vrha do dna.

DockPanel

Privzeto samodejno podaja elemente v vrstnem redu, v kakršnem so podani v XAML

datoteki, od leve proti desni. Pripete atribute DockPanel lahko uporabimo za spreminjanje

relativne postavitve podrejenih elementov.

XAML 70

Gradnik Canvas

Gradnik Canvas je objekt, ki služi za postavitev elementov datoteke XAML. Vsaka

XAML datoteka ima vsaj en objekt Canvas. Objekt Canvas definiramo na sledeč način:

<Canvas

Canvas.Left="10" Canvas.Top="310">

Gradnik Rectangle

Gradnik Rectangle opiše kvadratna ali pravokotna oblika, opcijsko z zaokroženimi

vogali. Definiramo ga na sledeč način:

<Rectangle Height="100" Width="100" Canvas.Left="5" Canvas.Top="5"

Stroke="Black" StrokeThickness="10" Fill="SlateBlue"/>

Grafične lastnosti

Poznamo naslednje grafične lasnosti:

• Opacity

• OpacityMask

• Clip

• RenderTransform

RAZVOJ APLIKACIJE Z ASP.NET 2.0 71

6. RAZVOJ APLIKACIJE Z ASP.NET 2.0

Uporabo opisanih gradnikov smo prikazali skozi razvoj spletne aplikacije »Projektno

vodenje«, ki vsebuje administratorski ter uporabniški del. Administratorski del je namenjen

samo administratorju in omogoča upravljanje z uporabniki ter upravljanje s projekti.

Uporabniški del je namenjen vsem registriranim uporabnikom in jim omogoča pregled

projektov ter upravljanje z njimi.

Diagram primera uporabe za administratorja je prikazan na sliki 6.1, diagram primera

uporabe za navadnega uporabnika pa na sliki 6.2. Na sliki 6.3 je prikazan razredni diagram

aplikacije.

Slika 6.1: Diagram primera uporabe za administratorja


Slika 6.2: Diagram primera uporabe za uporabnika

projekti

vnos_projektov()izpis_projektov()uredi_projekte()izpis_podrobnosti_projekta()

opravila projekta

vnos_opravil()izpis_opravil()uredi_opravila()brisi_opravila()

uporabnik

dodaj_datoteke()prijava()

Membership

ToString()GetUser()GetAllUsers()

Slika 6.3: Razredni diagram aplikacije

6.1 Zgradba aplikacije

Aplikacijo smo razvijali z orodjem Visual Studio 2005. Uporabili smo ASP.NET 2.0,

ki je namenjen za razvoj spletnih aplikacij. Uporabili smo gradnike ASP.NET 2.0. Za


nadgradnjo aplikacije z gradniki Atlas smo potrebovali knjižnico Atlas, ki smo jo našli na

spletnem naslovu [10] in je tipa odprta koda.

Za aplikacijo smo izdelali predlogo, kjer smo uporabili gradnik MasterPage (predloga

je prikazana na sliki 6.4). To spletno predlogo smo uporabili na vsaki strani, ki smo jo

projektu dodali.

Slika 6.4: Predloga spletne strani

Izdelava vlog ter ustvarjanje uporabnika projekta

Vsak projekt v Visual Studio 2005 vsebuje orodje Web Site Administation Tool, kjer

smo ustvarili vlogo za administratorja. Orodje je prikazano na sliki 6.5.


Slika 6.5: Web Site Administation Tool

S tem orodjem smo ustvarili vlogo, imenovano »administrator«, ki ima dostop do vseh

strani projekta. Vlogi administratorja smo podelili dostop do vseh strani projekta, drugim

anonimnim uporabnikom pa smo dostop do strani projekta omejili. To smo storili s pomočjo

metode Add New Access Rule. Slika 6.6 prikazuje metodo za upravljanje dostopa, ki je del

orodja Web Site Administation Tool.


Slika 6.6: Metoda za upravlanje dostopa uporabnikov

Prijava v sistem

Uporabnik se mora pred uporabo prijaviti v sistem, to pa stori tako, da vnese

uporabniško ime ter geslo. Če še nima uporabniškega imena, pa ima možnost registracije.

Slika 6.7. prikazuje gradnik Login.

Slika 6.7: Gradnik Login

Upravljanje z uporabniki

Administrator ima popoln nadzor nad uporabniki. Slika 6.8 prikazuje formo za dodajanje

uporabnikov. Administrator lahko uporabnike dodaja in ureja.


Slika 6.8: Forma za dodajanje uporabnikov

Upravljanje s projekti

Vsak prijavljeni uporabnik lahko dodaja ter ureja in briše samo svoje projekte. Slika

6.9 prikazuje gradnik FormView za upravljanje s projekti.

Slika 6.9: Gradnik FormView

Pri upravljanju s projekti smo uporabili gradnik FormView, ki omogoča urejanje,

brisanje ter osveževanje podatkov.


Uporaba AJAX ASP.NET v projektu

Projekt je izdelan s pomočjo tehnologije AJAX, ki omogoča osveževanje le dela

strani. Pri upravljanju s projekti smo uporabili gradnik AJAX, imenovan UpdatePanel, ki ga

definiramo takole:

<asp:UpdatePanel ID="UpdatePanel1" runat="server">

<ContentTemplate>

</ContentTemplate>

</asp:UpdatePanel>

Vanj smo na sledeč način vključili gradnik FormView:

<asp:UpdatePanel ID="UpdatePanel1" runat="server">

<ContentTemplate>

<asp:FormView>

</asp:FormView>

</ContentTemplate>

</asp:UpdatePanel>

6.1.1 Razvoj uporabniškega vmesnika z jezikom XAML

Vmesnik je izdelan v jeziku XAML, potrebno je bilo ogrodje 3.0, kjer smo uporabili

projekt Wpf/e. Slika 6.10 prikazuje ustvarjanje Wpf/e projekta.


Slika 6.10: Ustvarjanje projekta Wpf/e

6.2 Uporaba gradnikov jezika XAML v projektu

Gradnik TextBlock

Primer 6.1 ponazarja, na kakšen način definiramo gradnik TextBlock. Za ta gradnik

smo določili vizualne lastnosti. Slika 6.11 ponazarja rezultat gradnika.

<TextBlock FontSize="18"

FontFamily="Georgia"

FontStyle="Italic" FontWeight="Bold"

Canvas.Top="20" Canvas.Left="20">

Pozdravljeni na spletnih straneh za Vodenje Projektov!

</TextBlock>

Primer 6.1: definicija gradnika TextBlock


Slika 6.11: Izgled gradnika TextBlock

Gradnik Media

V jeziku XAML je uporaba gradnika Media zelo enostavna, predvajamo lahko

Windows Media Video ter Windows Media Audio datoteke. Za predvajanje vključimo

element <MediaElement>, ki mu določimo izvor video datoteke. Primer 6.2 prikazuje, kako

definiramo MediaElement.

<MediaElement Source="xbox.wmv" Width="300" Height="300" />

Primer 6.2 : Definicija gradnika MediaElement

Gradnik Button

Button smo izdelali s pomočjo elementa Rectangle in TextBlock. Na ta gumb smo

dodali dogodek, tako da smo ga dodali objektu Canvas (<Canvas

MouseLeftButtonDown="javascript:media_stop). Ta dogodek kliče funkcijo, ki je

definirana v programskem jeziku Javascript. Slika 6.12 prikazuje izgled gumbov.

Slika 6.12: izgled gumbov

Gumbe smo uporabili za predvajanje video posnetkov.

Gradnik Hyperlink


Hyperlink smo oblikovali s pomočjo gradnika TexBlock in Line. Elementoma smo

določili lastnosti prikazovanja na sledeč način:

<TextBlock Text="hyperlink" Foreground="Blue"/>

<Line Stroke="blue" StrokeThickness="1" X1="0" Y1="20" X2="65" Y2="20"

x:Name="Poglej projekte" Opacity="0"/>

Rezultat je viden na sliki 6.13.

Slika 6.13: Gradnik Hyperlink

Pri razvoju spletne aplikacije smo spoznali novosti ASP.NET 2.0. Spoznali smo

uporabo spletnih gradnikov. Uporabili smo novo komponento Atlas in spoznali delovanje

njegovih gradnikov. Prav tako smo uporabili nov označevalnik jezik XAML in v aplikaciji

uporabili ter spoznali nekaj njegovih gradnikov .

SKLEP 81

7. SKLEP

Osnovni namen diplomskega dela je bilo spoznati novosti tehnologije ASP.NET 2.0,

ki je namenjena za razvoj spletnih strani ter tehnologijo ASP.NET – Atlas. Spoznali smo

popolnoma nov označevalni jezik XAML.

Zaradi vse večjih potreb, ki jih je zahteval poslovni proces, se je razvil ASP.NET, vse

večja zahtevnost uporabnikov te tehnologije pa je botrovala razvoju ogrodja ASP.NET 2.0.

ASP.NET 2.0 vsebuje podporo v obliki grafičnih gradnikov, dodano je bilo veliko novosti,

ki pa smo jih spoznali v diplomi. Razvoj spletnih aplikacij je veliko lažji, manj zahteven, z

zelo malo programiranja. V prihodnosti bo razvoj s tako tehnologijo vedno bolj enostaven,

uporaben vsakomur.

Razvoj spletne tehnologije Atlas (sedaj imenovane AJAX) pa je omogočil prenos

deležev aplikacijskih procesov k odjemalcu, ki pri tem lahko komunicira s strežnikom v

ozadju. Omogoča izdelavo bogatih uporabniških vmesnikov spletnih aplikacij, ki vsekakor

povečajo produktivnost in omogočajo kompatibilnost z ostalimi brskalniki. V aplikaciji, kjer

smo uporabili Atlas, smo ugotovili, da utripa le del strani, kar je z uporabniškega vidika

velika prednost. Ajax uporablja asinhrono komunikacijo za pošiljanje in sprejemanje

podatkov. Ajax se je ves čas razvijal, in danes je njegova tehnologija obogatena z veliko

novimi spletnimi gradniki. V prihodnosti lahko pričakujemo, da bo ta tehnologija še

zmogljivejša in zelo razvita.

Spoznali smo tudi označevalni jezik XAML, ki smo ga uporabili za razvoj

uporabniških vmesnikov. Jezik XAML je jezik prihodnosti, v operacijskem sistemu

Longhorn je privzeti jezik za za razvoj vmesnikov. Jezik XAML je del ogrodja 3.0 in je še v

razvojni fazi, zato pri integraciji v tehnologijo ASP.NET nastopijo težave. Danes je razvoj te

tehnologije napredoval in Microsoft je razvil tehnologijo SilverLight, ki pa je že izšla in je

zelo poenostavila, ter izboljšala razvoj grafičnih vmesnikov.

LITERATURA 82

8. LITERATURA

[1] Bill Evjen, Scott Hanselman, Professional ASP.NET 2.0, Wrox, 2006

[2] Dino Esposito, Introducing ASP.NET 2.0, 2006

[3] Addison Wesley, A First Look At ASP.NET 2.0, 2006

[4] Wrox, Professional ASP.NET 2.0 Special Edition

[5] E. Cerami, Web Services Essentials: Distributed Applications with XML-RPC,

SOAP, UDDI & WSDL, 1. izd. O'Reilly, 2002

[6] Matthew MacDonald, Beginning ASP.NET 2.0 in C Charp, Apress, 2006

[7] Jon Flanders, Ian Griffiths , Chris Sells, Mastering Visual Studio .NET 2006

[8] Microsoft ASP.NET Atlas(AJAX) ogrodje, http://www.cmswire.com/cms/tips-

tricks/microsoft-aspnet-atlas-ajax-framework-preview-000658.php, sneto 10. 8. 2006

[9] Lori A. MacVittie, XAML in a Nutshell , 2007 [10] What Is ASP.NET AJAX? , http://atlas.asp.net/default.aspx?tabid=47, sneto 10. 8.

2006

[11] Bojan Vrhovnik, ASP.NET Ajax

[12] What is XAML?, http://www.xamlon.com/whatisxaml.aspx , sneto 10. 8. 2006

[13] Inside XAML, http://www.ondotnet.com/pub/a/dotnet/2004/01/19/longhorn.html,

sneto 11. 8. 2006

[14] Andrej Tozon , Windows Presentation Fundation v okolju Visual Studio 2008

[15] SamoPoljšak, Klemen Durn, Borut Slemenčič,

http://72.14.221.104/search?q=cache:BIfRIjkkMN8J:www.ailab.si/blaz/predavanja/skis/semi

narske/10.ppt+server+side&hl=sl&ct=clnk&cd=1&lr=lang_sl&client=firefox-a, sneto 12. 8.

2006

[16] http://www.amazon.com/Professional-ASP-NET-3-5-VB-Programmer/dp/0470187573

sneto dne 23.4. 2008

[17] Bojan Vrhovnik, Microsoft® Visual Studio 2008

[18] http://www.authorstream.com/Presentation/ Whats-New-NET-Framework-3-5-Visual-

Studio-2008-as-Entertainment-ppt-powerpoint/, sneto dne 23.4. 2008

PRILOGE 83

PRILOGE

- CD z ASP.NET – Atlas ter XAML rešitvijo spletne aplikacije, podatkovna baza.

PRILOGE 84

SEZNAM SLIK, TABEL IN PRAKTIČNIH PRIMEROV

Slika 2.1: Predloga strani ..........................................................................................................7

Slika 2.2: Orodjarna ..................................................................................................................9

Slika 3.1: Gradnika MultiView in View .................................................................................15

Slika 3.2: Združevanje razredov .............................................................................................21

Slika 3.3: Konfiguracija podatkovne povezave ......................................................................27

Slika 3.4: Ustvarjanje povezave ..............................................................................................28

Slika 3.5: Podatkovni gradnik XmlDatasource .......................................................................29

Slika 3.6: Definiranje podatkovnih metod ..............................................................................30

Slika 3.7: Spletni gradniki .......................................................................................................50

Slika 3.8 : Pregled programskiga okolja .................................................................................54

Slika 5.1. Možnosti WinFX aplikacije v Visual Studio 2005 .................................................66

Slika 6.1: Diagram primera uporabe za administratorja .........................................................71

Slika 6.2: Diagram primera uporabe za uporabnika ...............................................................72

Slika 6.3: Predloga spletne strani ............................................................................................73

Slika 6.4: Web Site Administation Tool .................................................................................74

Slika 6.5: Metoda za upravlanje dostopa uporabnikov ...........................................................75

Slika 6.6.: Gradnik Login ........................................................................................................75

Slika 6.7: Forma za dodajanje uporabnikov............................................................................76

Slika 6.8: Gradnik FormView .................................................................................................76

Slika 6.9: Ustvarjanje projekta Wpf/e .....................................................................................78

Slika 6.10: Izgled gradnika TextBlock ...................................................................................79

Slika 6.12: Gradnik Hyperlink ................................................................................................80

PRILOGE 85

Primer 2.1: Skladnost uporabnika ............................................................................................ 4

Primer 3.1: Uporaba gradnika HiddenField ........................................................................... 12

Primer 3.2 : Uporaba gradnika FileUpload ............................................................................ 14

Primer 3.3: Primer gradnika Wizard ...................................................................................... 16

Primer 3.4: Primer glave v Čarovniku ................................................................................... 17

Primer 3.5: Določanje delov slike, ki jih je mogoče klikniti.................................................. 18

Primer 3.6: Primer preobleke ................................................................................................. 23

Primer 3.7: Element UpdateParameters ................................................................................. 35

Primer 3.8 : Primer Kazala spletišča ...................................................................................... 43

Primer 3.9: Izvedba prijave za končnega uporabnika ............................................................ 47

Primer 4.1: Gradnik UpdatePanel .......................................................................................... 58

Primer 5.1: Ustvarjanje gumba .............................................................................................. 62

Primer 5.2: Lastnost gradnika gumb. ..................................................................................... 63

Primer 5.3: korenski element XAML datoteke ...................................................................... 64

Primer 6.2 : Definicija gradnika MediaElement .................................................................... 79

Tabela 3.1: Podatkovni gradniki .............................................................................................26

Tabela 3.2 : Lasnosti objekta Connection ...............................................................................39

Tabela 3.3: Metode razreda SqlBulkCopy ..............................................................................41

PRILOGE 1

Documents

RAZVOJ SPLETNIH APLIKACIJ Z ASP.NET 2.0, …UDK: 004.738.52:004.439(043.2) Abstract The diploma work introduces the description of a web application development tool ASP.NET, version