Nimetu (1)

1 HALB
Punktid

Esitatud küsimused

  • Kuidas saada tööle koodijupp, mis ei tööta ?
  • Mitu pirni ostad ?
  • Milliste sünniaastatega lapsed meil tabelis on ?
  • Milliseid andmeid esitada elementidena, milliseid atribuutidena ?
  • Kuidas raamistik aru saab, millist keelt kasutada ?
 
Säutsu twitteris
Sisukord
Eessõna
Hea õpilane!
Microsofti  arenduspartnerid ja kliendid otsivad pidevalt noori ja andekaid koodimeistreid, kes 
oskavad arendada  tarkvara  laialt levinud .NET platvormil. Kui Sulle meeldib programmeerida, siis 
usun, et saame Sulle pakkuda vajalikku ja huvitavat õppematerjali.
Järgneva praktilise ja kasuliku õppematerjali on loonud tunnustatud professionaalid. Siit leid 
uusimat infot nii .NET aluste kohta kui ka juhiseid veebirakenduste loomiseks. Teadmiste paremaks 
omandamiseks on allpool palju praktilisi näiteid ja ülesandeid. Ühtlasi on sellest aastast kõigile 
kättesaadavad ka videojuhendid, mis teevad õppetöö palju põnevamaks.
Oleme kogu õppe välja töötanud vabavaraliste  Microsoft   Visual   Studio  ja SQL  Server Express  
versioonide  baasil. Need tööriistad on mõeldud spetsiaalselt õpilastele ja asjaarmastajatele 
Microsofti platvormiga tutvumiseks. Kellel on huvi professionaalsete tööriistade proovimiseks, siis 
tasub lähemalt tutvuda õppuritele mõeldud DreamSpark programmiga 
( http://www.dreamspark.co m), mille kaudu saab alla  laadida  tehnilist tarkvara täiesti tasuta.
Microsofti eesmärk selliste õppematerjalide koostamisel on lihtne: tahame tuua kokku uusimat 
tehnoloogiat tundva põlvkonna, kes ületaks meie partnerite senised ootused ja tõstaks 
programmeerimise  lati  tasemele , kuhu me ise ulatunud pole. Sellesama materjali põhjal on edukalt 
testinud oma teadmisi Eesti kõige paremad arvutiõpetajad, sh ka Sinu kooli õpetaja!
Tulevased maailma parimad koodimeistrid, edu teile!
Rain  Laane
Microsofti Eesti esinduse juht
Sissejuhatus
Käesolev juhend on mõeldud kasutamiseks õppematerjalina Veebistuudiumis. Juhendis antakse 
edasi põhiteadmised, mis on vajalikud andmebaasipõhiste ASP.NET 3.5 veebirakenduste loomiseks. 
Koostades alustasime põhitõdedest ning väga keerulisi konstruktsioone ei käsitle. Selle juhendiga 
töötamiseks  piisab , kui on olemas huvi programmeerimise vastu. 
Kuigi .NET  raamistik  võimaldab koodi kirjutamist kümnetes erinevates keeltes, piirdume siin 
juhendis C# keelega, kui keelega, mis on spetsiaalselt loodud .NET  raamistiku tarbeks. 
Andmebaaside osas  vaatleme  SQL  Server 2008 võimalusi ning XML failide kasutamist.
Õppematerjali väljatöötamist toetasid Microsoft Eesti, BCS Koolitus ja Tiigrihüppe  Sihtasutus .
Avastamisrohkeid õpinguid!
Erki   Savisaar ja  Jaagup Kippar
BCS Koolituse lektorid
Õppematerjali kasutamise juhis
Siinses  materjalis  on hulgem lehekülgi ja peatükke. Esimese  hooga  võib see tekst väljatrükituna 
kätte võttes suisa ära ehmatada. See pole aga  sugugi   autorite  eesmärk. Kirjutist koostades on 
mõeldud nii algajate kui edasijõudnute peale. Et eesti keeles pole . NETi  kohta midagi põhjalikumat 
kirjutatud, siis püüab see õppematerjal sobida võimalikult  paljudele , kel teema kohta huvi või 
vajadus. Eks edasijõudnud suudavad juba ise sobivaid teemasid  leida ning ka veebist ja suurematest 
targematest raamatutest juurde otsida. Siin aga peaksid siiski nii veebirakenduste, andmebaaside kui 
ka „puhta“ programmeerimise kohta olema sees põhitõed, mille abil on enamik ettetulevatest 
olukordadest võimalik ära lahendada ning nende oskuste põhjal olla piisavalt tasemel, et  suuta  soovi 
korral arvutifirmasse praktikale minna ja mõne  ajaga  sealsesse töösse sulanduda.
Päris  algajatele  on valida kaks sisendpunkti, kust peaks saama alustada „tavainimese“ arvutialaste 
teadmiste – ehk siis teksti kirjutamise ja failide salvestamise oskusega. Lihtsam, ilusam ja 
värvilisem on ASP.NETi peatüki  algusosa , kus saab enesele veebilehe kokku panna ja seda soovide 
järgi kujundada. Edasi sealt juba oskused andmete lugemiseks ja salvestamiseks.
Kel aga tahtmist kohe tõsisemalt programmeerimismaailma siseneda, nende algajate jaoks peaks ka 
C# peatükk täiesti õpitav olema. Võrreldes veebimaailmaga on sealne  kasutajaliides  tunduvalt 
mustvalgem, aga selle eest on jälle tunduvalt vähem kohti, kuhu programmeerimise käigus eksida 
võiks. Esimese mõnekümne leheküljega saab ülevaate programmeerimise põhimõistetest ja –
võimalustest. Edasi  suuremaks  väljakutseks on objektorienteeritusega  seonduv , millest tänapäeval 
vähegi suurema programmi  kirjutamisel  ei saa üle ega ümber.  Viimased punktid C# juures aga on 
pigem edasijõudnutele erilisematel juhtudel hakkama saamise või siis sertifikaadieksamiks 
valmistumise tarbeks. Ka on kõrgkoolidel võimalus kasutada C# materjali oma programmeerimise 
põhikursuse  alusena  – senised katsed on olnud edukad .
Veebistuudiumi materjali muud peatükid on ka üles ehitatud põhimõttel, et lihtsamast ja tuttavamast 
keerukama ja võõrama poole. Andmebaaside juures alustamiseks on baasi ja tabeli loomine 
hädavajalik tegevus. Lihtsama  ülesehitusega päringud kuuluvad iga  rakenduse  juurde ning sageli 
saab nendega küllalt palju ära teha. Kui aga andmed keerukamad, siis paratamatult tuleb tabeleid 
siduda ning sobivate  väljavõtete saamiseks ka ridu grupeerida ning nende pealt tulemusi kokku 
arvutada. Praktiliste andmebaasirakenduste  koostamiseks  võiks  siinne  materjal päris hea aluse anda. 
Kui aga peetava kursuse eesmärgiks on anda ka andmebaaside projekteerimise põhialused (nagu 
kõrgkoolides kombeks), siis on vaja lisaks tutvuda veel andmemudelite, normaalkujude jm. 
andmebaasiteooria alla kuuluvate teemadega. 
Iga osa lõpus on ülesanded. Neid on püütud sättida nõnda, et keskmisel õppuril oleks  paras  jutt läbi 
lugeda, läbi mõelda, mõni näide ka järele proovida. Ning siis ülesanded ette võtta ja nende abil 
kogu lugu otsast peale uuesti läbi teha. Kui aga mõni ülesanne tundub juba tõsiselt tuttav ja liialt 
lihtne, eks selle või siis vahele jätta. Või kiiresti läbi proovida, et kas ikka on nii lihtne kui 
pealtnäha tundub. Samuti, kui pärast ülesannete läbitegemist  kipub vastav peatükk ikka segaseks 
jääma, tuleb kindlasti kasuks, kui enesele või oma õpilastele mõned teemakohased toimetused 
juurde mõelda ning sealtkaudu kogu lugu veel korra läbi katsetada. Kordamine on tarkuse  ema. 
Ning eriti hiljem aluseks olevate teemade puhul tuleb ikka kasuks, kui see  veelkord pulkadeni läbi 
näritud ja enesele selgeks tehtud on.
Soovitavat õppematerjali kasutusvõimalust saab vaadata ka järgneva skeemi pealt:
Kuidas saada abi küsimustele
Kõigepealt õnnitlused: vähemasti küsimus on olemas - seda polegi nii vähe. Igaks juhuks korda 
siiski küsimust mõttes mitu korda üle, et omal selge oleks, mida täpselt teada  tahad . Ja kui selle 
kohta midagigi on mõnes kättesaadavas õpikus olemas, siis loe sealt vastavad kohad üle. Kui 
esimese korraga vastust ei leidnud, pole  hullu . Loe igaks juhuks teine ja kolmas kord veel ning 
mõtle, et kas mõni lause võiks ehk niidiotsa anda, kus kannataks ise omal jõul edasi arutleda. Päris 
väheste, kuid samas kindlate algandmete ja  tubli  mõttetööga saab reaalmaailmas küllaltki palju 
kokku panna. Nii nagu füüsikas enamiku liikumisega seotud  arvutusi  saab teha paari lühikese 
valemi ja talupojamõistuse ning kannatuse põhjal, nii ka arvutiprogrammide loomisel pole 
hädavajalikke algandmeid kuigi palju. 
Kui aga oma mõistus siiski lootusetult tundub otsa saama, siis tasub abi otsida. Otsimootorid 
suudavad maailmast märkimisväärse osa andmeid välja pakkuda - kui ainult õige märksõna leiab. 
Üldistele muredele üldisi lahendusi on hulgem üles kirjutatud, aga neist midagi omale  sobivat  välja 
noppida on küllalt raske. Kui aga juba õnnestub täpsustada teema, programmeerimiskeel või 
otsingusse sisse anda konkreetse veateate tekst, siis on rohkem asjalikke vastuseid loota
strong >Microsofti - spetsiifiliste küsimuste korral leiab palju asjalikku abi aadressilt 
http://msdn.microsoft.com  - seda nii konkreetse keele/ tehnoloogia  alt kui ka üldtutvustuste kaudu. 
Igati põhjalik tasuta abimaterjal ka siis lugemiseks, kui konkreetseid küsimusi  parajasti  ei ole - küll 
lugemise peale näpud sügelema hakkavad ja tehes ka küsimused tekivad.
Kui peaksid õpingute käigus takerduma, siis oled teretulnud kasutama abi saamiseks Eneta 
kommuuniportaali foorumit www.eneta.ee/foorum. Kui jääd hätta programmide installeerimisega, 
tarkvara kasutamisega või Sul tekib mistahes muu Microsofti tehnoloogia kasutamisega seotud 
küsimus ja vajad nõu, siis Eneta foorumisse on kaasatud paljud asjatundjad sind abistama. Samuti 
peavad Veebistuudiumi lektorid ja korraldajad foorumitel silma peal ning katsuvad omaltpoolt 
murelikele pääseteid soovitada.
Kuidas saada tööle koodijupp, mis ei tööta?
Iga vähegi uue teema juures on selline küsimus täiesti loomulik. Saades  aga katsetuste abil 
kotermannist võitu, on lootust, et järgmised samateemalised lõigud juba lihtsamalt lähevad. 
Eriti hea, kui on võtta/kopeerida ligikaudu sarnast tööd tegev ning töötav näide - olgu õpikust, 
veebist, oma vanade näidete seast või mujalt. Pannes kõrvuti töötava koodi ning mittetöötava koodi, 
tasub hakata töötavat koodi ühe sammu kaupa uue koodi poole  muutma . Iga sammu järel 
kontrollides, et kas  rakendus  ikka tööle läheb. Kui sammud on piisavalt pisikesed, siis on hea 
vaadata, millise juures neist järsku töötamine lakkab - selle järgi juba võimalik edasi nuputada. 
Vahel juhtub ka  olukordi , kus töötavast näitest mittetöötava juurde liikumisel saadakse lõpuks 
pealtnähasamasugune, ent töötav kood. Siis on ju kõik hästi, mõistatuse põhjuseks sellisel juhul 
enamasti mõni sisse lipsanud või mujalt kaasa tulnud  vigane  sümbol, mis kompilaatori töö sassi 
ajab. Nõnda muutmise teel aga saab ka  sellistest   muredest  lahti. 
Kui pole käepärast niisama sobivat töötavat näidet, siis aitab vigasest näitest ridade/plokkide välja 
kommenteerimine. Et kui alles jäänud vaid tühi koodilõik koos algus- ja lõpusulgude/märkidega, 
siis see kas hakkab tööle, või on käivitusviga hoopis koodist väljapool. Näiteks kipub vahel 
juhtuma, et mõned koodifailid on jäänud ülekandmise käigus projektist välja ning seetõttu ei saa 
neid kasutada. Kui aga tühi koodilõik hakkab tööle, siis saab edasi rakendada juba sama taktikat, 
mis eelmises lõigus. Ehk siis rea või paari kaupa hakata koodi tagasi  panema , mõelda, et mis iga 
korraga uut peaks toimuma hakkama ning kontrollida, et kas nii ka hakkas.
Kui aga tundub, et kõik peaks õige olema, aga ikkagi toimub midagi kahtlast, siis tasub võtta 
detektiivi roll ning püüda  asuda  tõestama, et mõni stantardne koodikäsklus toimib vigaselt. Kõige 
kindlam  võimalus midagi tööle saada on tõestada, et seda pole olemasolevate vahenditega võimalik 
teha. Enamasti  selgub süstemaatilise läbiproovimise käigus siiski, et soovitud lahendus on tehtav  - 
kuigi mõnikord küllaltki pikka teed pidi. Paratamatult aga leidub kohti, kus ka 
programmeerimiskeele enese käsklus käitub vähemasti mõningates  olukordades  kõhutunde pakutust 
erinevalt. Vahel aitab sellistel puhkudel  manuaali  lugemine. Välistatud pole aga ka olukord, kus on 
võimalik tehnoloogia autoritele saata uhkusega kiri, kus kirjeldada leitud viga ning selle esinemise 
olukordi - enne muidugi mitmel moel selle  esinemist  ise läbi katsetades. Kui raamistik pole surnud, 
vaid elab järgmiste versioonide tekkimise näol edasi, siis sellised teated  on arendajatele igati 
tänuväärsed ning samas tõstavad  saatja  enesetunnet ja enesekindlust.
Microsoft .NET  platvorm
Microsoft .NET raamistik ( Framework ) on platvorm programmide loomiseks. Enne .NETi oli 
võimalik  programme  luua mitmetele erinevatele platvormidele nt DOS, Win32, Linux  jne. .NET 
platvormi loomise eesmärk on võtta  programmeerija  õlult kohustus tagada programmi ühilduvus 
erinevate  protsessorite  ja operatsioonisüsteemidega,  andes  rohkem aega programmiga 
põhifunktsionaalsusega tegelemiseks. Riistvara  ja operatsioonisüsteemidega ühilduvuse tagamine 
on jäetud raamistiku loojate hooleks.
Lisaks Microsoftile, kes pakub raamistiku Windowsi operatsioonisüsteemidele, arendatakse Novelli 
toetusel analoogset platvormi ka Linux, Solaris, Max OS X ja  Unix operatsioonisüsteemile (lisaks 
on toetatud ka Windowsi operatsioonisüsteem). Platvormi nimeks on Mono ning selle kohta saab 
rohkem lugeda aadressilt www.monoproject.com. Mõlemad lahendused baseeruvad ühtedel ja 
samadel ECMA/ISO poolt kinnitatud avatud standarditel. 
Kõige aluseks nende  platvormide  loomisel on CLI e. Common Language  Infrastructure, mis 
kirjeldab ära, millised peavad olema keeled, mida platvormil saab kasutada ning millisele   kujule  
peavad nendes keeltes kirjutatud koodid kompileeruma. CLI üks huvitav omadus on see, et enam 
pole vahet, millises keeles programmeerid, sest kompileeritud kood on lõpuks ikkagi sama. Seega 
saab iga programmeerija valida endale just selle keele, mis kõige hingelähedasem. 
Järgmine tase on CLR e. Common Language Runtime (Mono puhul CLI  virtual  machine), mis 
pakub hallatud (turvalist) keskkonda programmeerimiseks. Selles hallatud keskkonnas on keskse 
kontrolli all klasside laadimise e. mälu hõivamine, mälu vabastamine (Garbage collector) ning 
vahekoodi  kompilaator  masinkoodiks. Lisaks pakub CLR programmi loomiseks vajalikke  klasse
Lisaks klasside kasutamise võimalusele on paljud neist ka päritavad e. nendest  on võimalik pärimise 
teel luua oma klasse. 
Kõrval asuvalt diagrammilt on näha, et raamistik lisab uue kihi programmi ja riistvara vahele, mis 
loomulikult ei mõju hästi programmi jõudlusele. Hea uudis on see, et Microsofti .NET raamistik 
integreerub üsna ilusti Windowsi sisse  muutudes  osaks Windowsist. Enamgi  veel, kui võtta 
Microsofti viimane  Windows  e.  Vista  siis raamistik ongi Windows! See tähendab seda, et kõik 
klassid  ja meetodid, mida Microsoft kasutab oma operatsioonisüsteemi loomisel, on kasutamiseks 
ka kõigile teistele arendajatele, mis omakorda annab kätte väga võimalusterohked vahendid kiiresti 
funktsionaalsete programmide ehitamiseks.
CLR rakenduste kompileerimine käib kahes faasis:

1. Esimese sammuna programmeerija kompileerib oma lähtekoodi vahekeelde. Microsofti 

raamistiku puhul on selleks MSIL (Microsoft  Intermediate  Language).

2. Teise  sammuga  käivitamise hetkel CLRi kooseisus olev kompilaator kompileerib MSILi 

masinkoodi, mida  protsessor hakkab täitma. Kompileeritakse vaid need osad programmist, 
mida kasutatakse e. kompileerimine on kiire, kuigi esimene käivitamine võib olla  aeglasem  
kui kohe binaarsel kujul  oleval  programmil.
Viimasel hetkel kompileerimise eelis seisneb selles, et protsessorile käivitamiseks mõeldud 
binaarset koodi on võimalik optimeerida täpselt selle protsessori jaoks, mis hakkab programmi 
jooksutama. Ei ole vahet, kas protsessor on 32 või 64 bitine jne.
Tulles nüüd tagasi Microsofti .NET platvorm juurde siis see pole mitte üksnes CLR, vaid toodete 
kogumik, mis sisaldab kõiki vajalikke vahendeid jagatud rakenduste ehitamiseks,  pakkudes  keelest 
sõltumatut, ühtset programmeerimise mudelit programmi kõigi kihtide jaoks. .NET platvorm toetab 
täielikult Interneti platvormist sõltumatuid ja standardseid tehnoloogiaid nagu HTML, XML ja 
SOAP .
.NET platvormiga seotud tooted võib jagada 4 kategooriasse:

3. .NET raamistik – baseerub Common Language Runtime’l (CLR). CLR pakub baasteenuseid 

ja klasse programmide loomiseks, sõltumata keelest ja programmi  kihist .

4. .NET My  Services  – on kogumik kasutajatele suunatud XML veebiteenuseid. Nende 

teenuste hulka kuuluvad: .NET Passport autentimine, meeldetuletuste  saatmine  ja 
vastuvõtmine, personaalse info ja andmete salvestamise võimalus
5. .NET Enterprise Servers – pakuvad lisafunktsioone ärirakenduste tarbeks. Enterprise 
serverid on nt SQL Server (andmebaaside tarbeks), Exchange  (kirjavahetuse jaoks) jne
6. Visual Studio – Vahend .NET rakenduste loomiseks. Lisainfot Visual Studio kohta saab 
Microsoft veebist  http://msdn.microsoft.com/vstudio. Visual Studio 2008st on olemas 
mitmeid versioone. Programmeerimistee alustamiseks ja katsetamiseks on loodud 
spetsiaalsed tasuta versioonid Visual Studio Express näol. Express versioone on võimalik 
tõmmata aadressilt  http://msdn.microsoft.com/express . Selle kursuse raames on kasu kahest 
versioonist Visual Web  Developer 2008 Express – ASP.NET 3.5 veebirakenduste loomiseks 
ja Visual C# Express  Edition lihtsalt C# keeles programmeerimise jaoks. 
Selleks, et .NET  platvormile  loodud programme käivitada, on vaja .NET raamistikku. Juhul, kui 
Teil seda arvutis veel ei ole, on seda võimalik tõmmata mitmelt veebilehelt, sh Windows  Update 'st 
või www.microsoft.com/net
 
Programmeerimiskeeltena on vaikimisi võimalik kasutada (kompilaatorid sisalduvad .NET 
raamistikus) C#, hallatud C++, VB.NET ja J# keeli. Lisaks nendele pakutakse erinevate tootjate 
poolt veel ca 40 .NET keelt.
Microsoft on .NET raamistikust loonud juba mitmeid versioone. Selle materjali loomise hetkeks on 
väljas  versioon  3.5 koos SP1 teenusepaketiga. Hea uudis nende paljude versioonide juures on see, et 
igas uues versioonis sisaldub ka vana e. midagi tuleb juurde, kuid kõik see, mis oli, töötab edasi!
Kui vaadelda erinevaid .NET 
raamistiku versioone siis selgub, et 
.NET põhifunktsionaalsus pärineb 
hetkel versioonist 2.0, millele on siis 
lisatud funktsionaalsust järgnevate 
versiooniuuendustega.
Versiooniga 3.0 lisati juurde:
WPF – Windows Presentation 
Foundation so uus  kasutajaliidese  
ehitamise  liides , mis asendab 
Winform’id. WPF baseerub XMLil 
ning vektrograafikal, mis oskab 
kasutada 3D  arvutigraafika  riistvara 
ning Direct  3D tehnoloogiat.
WCF – Windows Communication 
Foundation so teenusepõhine 
teadetevahetussüsteem, mis võidab 
programmidel suhelda nii lokaalselt 
kui ka üle võrgu. Asendab Web 
Serviced
WF – windows Workflow Foundation võimaldab automatiseerida tegevuste sooritamist ning luua 
erinevatest tegevustest transaktsioone kasutades töövooge.
Windows CardSpace – tarkvarakomponent, mis hoiustab turvaliselt kasutaja digitaalseid 
identiteetiteete ning pakub ühtset liidest identiteedi valimiseks erivatele transaktsioonidele nagu nt 
veebilehele sisselogimine.
Versiooniga 3.5 lisandus LINQ – Language  INtegrated  Query, mis pakub ühtset päringute 
kirjutamise liidest erinevat tüüpi andmeallikatele. Päringute loomise käsustik on integreeritud keele 
sisse, sellest tulenevalt kaasnevad .NET 3.5ga ka uued versioonid keeltest C# ja VB.NET. Esialgu 
on koos raamistikuga kaasas LINQ teenusepakkujad päringute tegemiseks  objektidest , XMList ja 
SQL Serverist.
Lisainfot .NET raamistiku erinevate versioonide kohta leiate aadressilt 
http://en.wikipedia.org/wiki/.net_framework#versions/ 
C#
Mõnigi võib ohata, et jälle üks uus programmeerimiskeel siia ilma välja mõeldud. Teine jälle 
rõõmustab, et midagi uut ja huvitavat sünnib. Kolmas aga hakkas äsja veebilahendusi kirjutama ja 
sai mõnegi ilusa näite  lihtsasti  kokku. Oma soovide  arvutile  selgemaks tegemise juures läheb varsti 
vaja teada, "mis  karul  kõhus on", et oleks võimalik täpsemalt öelda, mida ja kuidas masin tegema 
peaks. Loodetavasti on järgnevatel lehekülgedel kõigile siia sattunute jaoks midagi sobivat. Mis 
liialt lihtne ja igav tundub, sellest saab kiiresti üle lapata. Mis esimesel pilgul paistab arusaamatu, 
kuid siiski vajalik, seda tasub teist korda lugeda. Ning polegi loota, et kõik kohe lennult külge 
jääks!?
Selle jaoks on teksti sees koodinäited, mida saab kopeerida ja arvutis tööle panna. Ning mõningase 
muutmise ja katsetamise peale  avastada , mis mille jaoks on ning kuidas seda oma kasuks rakendada 
saab. Töötav näide on üks hea kindel tugipunkt nagu üks suur puu lagendikul, kuhu oskab alati 
tagasi minna. Juhul, kui muutmistega on õnnestunud oma koodilõik nii sõlme keerata, et see sugugi 
enam töötada ei taha, saab alati võtta materjalist taas algse töötava näite ning sealt juurest katsetama 
hakata. 
Kes  pikemalt  mitmesuguseid rakendusi kirjutab, avastab mõne aja pärast, et samas keeles kirjutatud 
programm võib vähemalt esmapilgul mõnevõrra erinev välja näha sõltuvalt sellest, kas programm 
käivitatakse veebist, tegutsetakse nuppudega ja tekstiväljadega  aknas , väljundiks on mobiiltelefon 
või  piirdub kogu tegevus tekstiaknaga. Esimesel korral võib tunduda, et oleks nagu täiesti eri 
keeltes ja eri moodi kirjutamine. Ühes kohas on alati koodi juures salapärane button1_click, 
teises public static void Main ning kolmandas veel midagi muud. Aga sellest ei tasu ennast 
väga häirida lasta.  Ehkki  .NETi ja C# juures on püütud eri kohtades käivituvate rakenduste loomist 
sarnasemaks muuta, tuleb siiski kirjutamisel arvestada käivitumiskoha võimalustega. Siin materjalis 
keskendume C# keele ülesehitusega seotud teemadele, mis on ühised kõigi käivitumiskohtade 
puhul. Ning kasutajaliidesena pruugime programmeerimisõpikute traditsioonilist lihtsat ning 
väheste (eksimis)võimalustega tekstiakent - nii jääb rohkem aega tähelepanu pühendada keele enese 
konstruktsioonidele, mida siis edaspidi julgesti veebirakenduste juures ja soovi korral mujalgi 
pruukida. Kes aga tahab omale koodi kirjutamiseks rohkem abivalmis ning lisavõimalustega 
keskkonda, sellele soovitame lugeda peatükki nimega Visual Studio C# Expressi  install  – samm 
sammult  juhis vastava keskkonna paigaldamiseks ning esimese rakenduse käivitamiseks. Edasine 
kirjutamine sarnaselt konspektis olevale.
Põhivõimalused
Kui rakendus juba mingitki elumärki annab, on see tunduvalt rohkem, kui lihtsalt hulk 
koodi, mis peaks "midagi arukat" tegema. Tunne, et suutsin programmi ise, omade roosade 
kätega käima panna, on hea. Ja annab kindlustunde, et järgmisel korral saab asi ainult 
paremaks minna. Kui käima on lükatud, siis edasi võib mõtelda juba juurde panemise peale. 
Nii nagu talumees, kes omale krati oli ehitanud, sai hakata talle ülesandeid andma alles siis, 
kui  kratt hinge sisse võttis. Muul juhul on tegemist palja põhuhunnikuga, millele  teivas  sisse 
löödud ja vanad kartulikorvid külge riputatud - olgu need nii suured ja vägevad tahes. Tööle 
hakkamiseks on hinge vaja. Aga hinge ei saa enne sisse puhuda, kui väikegi tervik olemas. 
Ning C# puhul näeb lühim tervikprogramm välja ligikaudu järgmine:

using System;
class Tervitus {
   public static void Main( string [] arg){
      Console. WriteLine ("Tere");
   }
}
Esmapilgul võib tunduda, et suur hulk tundmatuid sõnu on ekraanile   ritta  seatud. Ning veel mõned 
sulud ka. Ning kui teada saada, et kõik see pikk jutt on vaid väikese programmi loomiseks, mis oma 
töö tulemusena ütleb "Tere", siis võib paista, et tegemist on ilmse raiskamisega. Eriti, kui mõni on 
varem tutvunud Basicu või Pythoniga, kus sama tulemuse saamiseks tuleb lihtsalt kirjutada
print "Tere"
Seetõttu veel 2000ndate aastate alguses tutvustati inimesi programmeerimisega mitmeski koolis just 
Basicu kaudu, sest algus on "nii lihtne". Ning kui  programmid  "väga suureks" - ehk siis tuhandete 
ridade  pikkuseks  - ei kasva, võib julgesti lihtsa algusega keele juurde jäädagi. Kõik vajalikud 
matemaatikaülesanded, kirjutamised ja arvutamised saavad tehtud. 
Aga millegipärast on programmidel kombeks paisuda. Ning et suureks paisunud rakenduse seest 
sobiv toiming üles otsida, peab  lisama  vajalikule käsule üha uusi ja uusi kesti. Nii nagu üheainukese 
vajaliku sidekanali puhul võib korraldada nii, et telefonitoru tõstes ühendatakse rääkija kohe õigesse 
kohta. Kümnekonna puhul piisab telefoninumbritest, mis telefoni külge kleebitud või kiirklahvidele 
salvestatud. Kui aga  raamatupidaja  peab vajalikul hetkel kätte saama kõik temaga viimastel aastatel 
suhelnud kliendid, siis läheb juba tarvis korralikumat  kataloogi .
Nõnda on C# ja ka mitme muu keele  loojad otsustanud juba alguses programmikoodi osad 
korralikult süstematiseerida, et poleks vaja piltlikult öeldes pärast kataloogi tehes nuputada, millist 
värvi paberilipikule kirjutatud Mati telefoninumber just selle õige Mati oma on. Mõnevõrra läheb 
tekst selle peale küll pikemaks, aga loodetavasti piisavalt vähe, et ikka julgete C# võlusid tundma 
õppida.
C# kood jaotatakse üksteise sees olla võivatesse plokkidesse. Iga ploki ümber on looksulud . Siinses 
näites on välimiseks plokiks klass nimega Tervitus ning tema sees alamprogramm nimega Main. 
Plokke võib vahel tunduvalt rohkem olla.  Omaette  terviklikud  toimingud  paigutatakse üldjuhul 
alamprogrammidesse. Nende sees võivad olla plokid tingimuste ja korduste tarbeks. Klassi 
moodustab üheskoos toimivate või sarnaste alamprogrammide komplekt (näiteks 
matemaatikafunktsioonid) - sellest pikemalt aga hiljem objektinduse juures. Suuremate rakenduste 
juures jagatakse klassid veel omakorda nimeruumidesse. Nii on lootust ka pikemate rakenduste 
puhul midagi hiljem koodist üles leida.
Mõned salapärased kohad on veel jäänud. Esimene rida
using System;
teatab , et nimeruumist System pärinevaid klasse saab kergesti kasutada - piisab vaid klassi 
nimetamisest. C# standardpaketis leidub tuhandeid kasutamisvalmis klasse. Lisaks veel loendamatu 
hulk lisapakette, mis muud programmeerijad  on valmis kirjutanud. Kindlasti leidub nende hulgas 
korduvaid klassinimesid - sest mõttekaid ja kõigile arusaadavaid klassinimetusi lihtsalt ei saa olla 
nii palju. Kui aga samanimelised klassid on eri nimeruumides, siis nad üksteist üldjuhul ei sega. Nii 
võib igaüks oma nimeruumis nimetada klasse kuidas tahab. Ja using-lausega märgitakse, millist 
klasside komplekti parajasti kasutatakse. Edasi siis
class Tervitus{
mis praegusel juhul annab programmile ka nime ning
   public static void Main(string[] arg){
näitab alamprogrammi Main, kust käsurearakendus oma tööd alustab. Muudest sõnadest siin rea 
peal ei tasu end veel liialt häirida lasta. Kiirülevaatena: public näitab, et pole seatud käivitusõiguse 
tõkkeid, static - et alamprogramm Main on olemas ja käivitusvalmis kohe rakenduse töö alguses. 
void näitab, et ei raporteerita operatsioonisüsteemile programmi töö edukuse kohta. Ja 
ümarsulgudes oleva abil saab mõnes rakenduses kasutaja omi andmeid ette anda - siin seda 
võimalust aga ei kasutata.
Järgneb kasutajale nähtav toiming, ehk
      Console.WriteLine("Tere");
Console klass asub nimeruumis System ja on üleval märgitud using lause tõttu kasutatav. Klassi 
käsklus WriteLine lubab kirjutada konsoolile ehk tekstiekraanile. Praegu piirdutakse ühe väikese 
teretusega. Jutumärgid on ümber selleks, et arvuti saaks aru, et tegemist on tekstiga  - mitte näiteks 
käskluse või  muutuja  (märksõna) alla salvestatud  andmetega .
   }
}
Kaks  sulgu lõpus lõpetamas  eespool  avatud sulgusid. Iga  sulg , mis programmikoodi sees  avaneb
peab ka kusagil lõppema - muidu ei saa arvuti asjast aru, hing ei tule sisse ja programm ei hakka 
tööle. Tühikud ja reavahetused on üldjuhul vaid oma silmailu ja pildi korrastuse pärast. 
Kompilaatori jaoks võiks kõik teksti rahumeeli ühte ritta jutti kirjutada, enesele kasvaks aga selline 
programm varsti üle pea. Siin näites paistab, et alamprogramm Main' i sulg on sama kaugel taandes 
kui alamprogrammi alustav rida ise. Ning klassi sulg on sama kaugel kui klassi alustava rea sulg. 
Nõnda saab programmi pikemaks kasvamisel kergemini järge pidada, millises  plokis  või millistes 
plokkides vaadatav käsk asub. 
Nõnda on esimene väike programm üle vaadatud ja loodetavasti tekib natuke tuttav tunne, kui 
vaadata järgnevaid ridu:
using System;
class Tervitus{
   public static void Main(string[] arg){
      Console.WriteLine("Tere");
   }
}
Käivitamine
Edasi tuleb tervitusrakendus käima saada. Töö tulemusel tekkinud pildi võib arenduskeskkonnas 
(näiteks Visual Studio 2008) ette saada kergesti - vajutad lihtsalt käivitusnuppu ja midagi ilmubki. 
Kuidas rakendus paigaldada, seda saab lugeda C# osa lõpust.  Et aga "karu kõhust" tekiks parem 
ülevaade, püüame tervitaja käsurealt tööle saada. Sealt paistab paremini välja, millised etapid enne 
läbi käiakse, kui töötava programmini jõutakse. See on kasulik näiteks  vigade   otsimisel  ja neist aru 
saamisel.
C# programmi kood salvestatakse laiendiga cs. Faili nime võib panna loodud programmi klassiga 
samasuguseks, kuigi otsest kohustust ei ole. Aga nõnda on kataloogist omi programme ehk kergem 
üles leida, kui klass ja fail on sama nimega.
Käsureale pääsemiseks on tarvilik see avada. Tavaliseks mooduseks on Start -> run ja sinna sisse 
käsklus cmd. Et sealtkaudu kompilaatorile ligi pääseda, on lisaks vaja panna otsinguteesse 
kompilaatori csc.exe kataloogi aadress, mis ühe konkreetse  installatsiooni  puhul on näiteks 
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727.
Lihtsam  moodus  on kasutada Microsoft .NET Framework SDK-ga kaasa tulevat SDK Command 
Prompt' i, kus vastav  seadistus  juba paigas.
Edasi tuleb käsuaknaga  liikuda  kataloogi, kuhu programmikoodifail salvestatud sai. Siinpuhul  on 
selleks C ketta   Projects  kataloogi alamkataloogi oma alamkataloog näited. Käsureal liikumiseks 
saab ketast valida käsuga, mis koosneb kettatähest ja temale järgnevast koolonist. Kataloogides 
liikumiseks sobib käsklus cd. Nii et siin puhul tuleb ketta valimiseks kirjutada
C:
ning sealt seest kataloogi valimiseks
cd \TEMP\naited
Nõnda jõudsingi sobivasse  asukohta . Kataloogi sisu nägemiseks sobib käsklus dir. Tulemus:
C:\TEMP\naited>dir
  Volume in drive C has no label.
 Volume Serial Number is 0C0F-6FEC
 Directory of C:\TEMP\naited

08.10.2008  16:46              .
08.10.2008  16:46              ..

08.10.2008  16:46               121 Tervitus.cs
               1 File(s)            121 bytes
               2 Dir(s)  22 939 922 432 bytes free
Siit paistab, et kataloogis on üks fail. Selle nimeks on Tervitus.cs ning pikkuseks 116 baiti .
Käivitamiseks tuleb meie loodud programmikoodiga  tekstifail  kõigepealt ära kompileerida. 
Kompileerimise käigus tehakse käsklused masinale kergemini loetavamaks. C# käsurearakenduse 
puhul on kompileerimise tulemuseks .exe - laiendiga fail, mis oma käivitumiseks vajab, et .NET 
keskkond oleks masinas juba olemas. Kompileerimiseks  kirjutatakse  kompilaatorprogrammi nimi 
(csc) ning programmikoodifaili nimi (praegu Tervitus.cs). Kui programmikood on masinale 
arusaadavalt kirja pandud, veateateid ei  anta  ning kataloogi tekib juurde käivitamisvalmis 
Tervitus.exe
C:\TEMP\naited>csc Tervitus.cs
Microsoft (R) Visual C# 2008 Compiler version 3.5.30729.1
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation . All rights reserved.
Käima panekuks tuleb vaid selle .exe faili nimi kirjutada ning võimegi tulemust näha.
C:\TEMP\naited>Tervitus
Tere
Ülesandeid
* Muuda väljatrükitavat teksti
* Kirjuta ekraanile kaks rida (kaks järjestikust Console.WriteLine käsklust, kumbki omal  real )
* Tekita programmi sisse väikeseid vigu, ja vaata, mis kompilaator selle peale teatab. Paranda tagasi 
ja veendu, et programm töötab jälle. Näiteks kaota ära n-täht sõnast Console, üks jutumärk "Tere" 
ümbert, üks sulg, semikoolon, muuda klassi nime. Ja igal korral jäta meelde või soovi korral suisa 
märgi üles, kas ja milline viga oli tegelikult ning millise veateate andis kompilaator. Sellised on 
kõige tüüpilisemad kompileerimisel  tekkivad  vead. Kord väikese programmi juures läbi katsetatuna 
on kergem sellistest veateadetest ka suures rakenduses aru saada.
Suhtlus arvutiga
Enamik programme vajavad andmeid  kasutajalt  - muul juhul ei  teaks  ju arvuti, mida meil vaja on. 
Kui just programmi ainsaks ülesandeks polegi kellaaja teatamine, sest sellisel juhul tõesti piisab 
vaid programmi enese käivitamisest.
Sisendite võimalused sõltuvad programmi kasutuskohast.  Veebis  näiteks saame pruukida veebilehel 
töötavaid graafikakomponente - nuppe , tekstivälju, rippmenüüsid jne. Windows Formide ehk 
arvutis iseseisvalt (mitte veebi kaudu) töötavate graafiliste rakenduste puhul on tavalised  
graafikakomponendid suhteliselt sarnased veebis nähtavatega. Vaid mõnevõrra vabamalt pääseb 
oma komponente juurde tegema ning mitmekülgsemaid võimalusi kasutama. Tekstiakna rakenduste 
juures piirdub suhtlus arvutiga loetava ja trükitava tekstiga. Lihtsaim dialoogi pidav programm näeb 
välja järgmine:
using System;
class Sisend {
   public static void Main(string[] arg){
      Console.WriteLine("Palun eesnimi :");
      string eesnimi=Console.ReadLine();
      Console.WriteLine("Tere, "+eesnimi);
   }
}
Ning töö paistab välja nii:
C:\Projects\oma\naited>Sisend
Palun eesnimi:
Juku
Tere, Juku
Esmane "Palun eesnimi" trükitakse välja sarnaselt nagu lihtsaimaski tervitavas  programmis
Edasine Console.ReadLine() jääb kasutajalt sisestust ootama. Kõik, mis kasutaja kuni 
reavahetuseni kirjutab, püütakse kokku üheks tekstiks ning selle saab arvutisse  meelde jätta. 
Märksõnaks ehk muutuja nimeks sai "eesnimi" ning andmetüübiks "string", mis inimkeeli tähendab 
teksti. Järgmisel real trükitakse tulemus välja. Nõnda sõltub programmi vastus küsimise peale 
sisestatavast nimest.
Arvutamine
Arvutamine teadupärast arvuti põhitöö - vähemalt arvutustehnika algaastatel. Et siin lahkesti 
kasutaja antud arve liita/lahutada saaks, tuleb kõigepealt hoolitseda, et need ka arvuti jaoks arvud ja 
mitte sümbolite  jadad oleksid. Kõigepealt annab ReadLine kätte numbriliste sümbolitega teksti. 
Ning käsklus int. Parse  muudab selle arvutuste jaoks kõlbulikuks. Tüüp int (sõnast integer) 
tähistab täisarvu. Kui on vaja komakohtadega ümber käia, siis sobib selleks tüüp  double . Teise arvu 
puhul on andmete lugemine ning arvuks  muundamine  ühte käsklusesse kokku pandud. Nii võib ka.
Väljatrüki juures näete kolme looksulgudesse paigutatud arvu. Nõnda on võimalik andmeid 
trükkides algul määrata ära trükkimise kohad ning alles pärast loetellu kirjutada  tegelikud  
väärtused. Juhul, kui väärtuste arvutamine on pikk (näiteks arv1*arv2), aitab see programmikoodi 
pilti selgemana hoida. Muul juhul tuleks hulk pluss- ja jutumärke väljatrüki juurde. Jutumärgid 
tekstide eristamiseks ning plussmärgid üksikute osade kokku liitmiseks. Samuti on sellisest 
asukohanumbritega paigutamisest kasu juhul, kui rakendust tõlgitakse. Keele lauseehituste tõttu 
võib sõnade järjestus  lauses  muutuda.  Selliselt  looksulgude vahel olevate  arvudega  mängides aga 
saab lihtsamalt tõlkida ilma, et peaks selleks programmikoodis märgatavaid muutusi tegema.
using System;
class Arvutus{
   public static void Main(string[] arg){
      Console.WriteLine("Esimene arv:");
      string tekst1=Console.ReadLine();
      int arv1=int.Parse(tekst1);
      Console.WriteLine("Teine arv:");
      int arv2=int.Parse(Console.ReadLine());
      Console.WriteLine("Arvude {0} ja {1} korrutis on {2}",
              arv1, arv2, arv1*arv2);
   }
}
C:\Projects\oma\naited>Arvutus
Esimene arv:

3
Teine arv:
5
Arvude 3 ja 5 korrutis on 15
Ülesandeid

* Küsi kahe inimese nimed ning teata, et täna on nad pinginaabrid
* Küsi ristkülikukujulise toa seinte pikkused ning arvuta põranda pindala
* Leia 30% hinnasoodustusega hinna põhjal alghind
Valikud
Ehk võimalus otsustamiseks, kui on vaja, et programm käituks kord üht-, kord teistmoodi. 
Allpoololev näide koos väljundiga võiks näidata, kuidas  tingimuslause  abil tehtud valik toimib.
using System;
public class Valik1{
   public static void Main(string[] arg){
      Console.WriteLine("Palun nimi:");
      string eesnimi=Console.ReadLine();
      if(eesnimi=="Mari"){
         Console.WriteLine("Tule homme minu juurde!");
      } else {
         Console.WriteLine("Mind pole homme kodus.");
      }
   }
}
Väljund:
D:\kodu\0606\opikc#>Valik1
Palun nimi:
Juku
Mind pole homme kodus.
Nagu näha - Jukut külla ei kutsutud. C# juures, nii nagu selle aluseks oleva C-keele puhul 
kasutatakse võrdlemise juures kahte võrdusmärki. Üks võrdusmärk on omistamine  ehk 
kopeerimine. Arvude puhul saab kasutada ka võrdlusi  ehk suurem kui ja väiksem kui. Näiteks
if(vanus>14){
   Console.WriteLine("Tuleb osta täispilet");
}
Samuti kehtivad võrdlused >= ja 6 && vanus Valik2
Mitu pirni ostad?

3
Kas kilekotti ka soovid? (jah/ei)
jah
Kogusumma : 5,8
*/

Kui  soovida  üksikutest osadest  summat  kokku arvutada nagu ülal näites, siis on küllalt tavaline, et 
iga küsimuse peal otsustatakse, kas ja mida selle juures teha. Siin nagu näha - juhul kui  kilekott  
ostetakse lisaks, siis pannakse hinnale 70 senti juurde. 
summa=summa+0.70
tähendab just seda.
Ülesandeid
* Küsi temperatuur ning teata, kas see on üle kaheksateistkümne kraadi ( soovitav toasoojus talvel).
* Küsi inimese pikkus ning teata, kas ta on lühike, keskmine või pikk (piirid pane ise paika)
* Küsi  inimeselt  pikkus ja sugu ning teata, kas ta on lühike, keskmine või pikk (mitu 
tingimusplokki võib olla üksteise sees).
* Küsi inimeselt poes eraldi kas ta soovib osta piima, saia, leiba. Löö hinnad kokku ning teata, mis 
kõik ostetud kraam maksma läheb.
Kordused
Arvutist on enamjaolt kasu siis, kui ta meie eest mõned sellised tööd ära teeb, kus  enesel  tarvis 
ükshaaval ja üksluiselt sama toimetust ette võtta. Ühest hinnast paarikümne protsendi maha 
arvutamisega saab ka käsitsi mõne ajaga hakkama. Kui aga hindu on mitukümmend, siis on päris 
hea meel, kui arvuti selle töö meie eest ära teeb. Järgnevalt näide, kuidas arvuti vastu tulevale  viiele  
matkajale tere ütleb. Täisarvuline muutuja nimega nr näitab, mitmenda  matkaja  juures parajasti 
ollakse. Käskluse  while  juurde kuuluvat  plokki  saab korrata. Plokk  läbitakse üha uuesti juhul, kui 
ümarsulgudes olev tingimus on tõene. Et kordusi soovitud arv saaks, on juba programmeerija 
hoolitseda. Selleks on siin igal korral pärast tervitust käsklus nr=nr+1, ehk siis suurendatakse 
matkaja järjekorranumbrit. Kui see  suurendamine   kogemata  tegemata jääks, siis jääkski arvuti 
igavesti  esimest matkajat teretama (proovi järele). Nüüd aga töötav korduste näide: 
using System;
public class Kordus1{
   public static void Main(string[] arg){
      int nr=1;
      while(nrKordus1
Tere, 1. matkaja!
Tere, 2. matkaja!
Tere, 3. matkaja!
Tere, 4. matkaja!
Tere, 5. matkaja!
Heal lapsel mitu nime. Ehk ka korduste kirja panekuks on mitu moodust välja mõeldud. Algul 
näidatud while-tsükkel on kõige universaalsem, selle abil on võimalik iga liiki kordusi kokku 
panna. Sama tulemuse aga saab mõnevõrra lühemalt kirja panna for-i abil. Levinud kordusskeemi 
jaoks on välja mõeldud omaette käsklus, kus algul  luuakse  muutuja ja antakse talle algväärtus; 
seejärel kontrollitakse, kas järgnevat plokki on vaja täita; lõpuks võetakse ette toiming andmete 
ettevalmistamiseks uue ploki jaoks. nr++ on sama, mis nr=nr+1 - ehk siis suurendatakse muutuja 
väärtust ühe võrra. Näha programminäide:
using System;
public class Kordus2{
   public static void Main(string[] arg){
      for(int nr=1; nrKordus2
Tere, 1. matkaja!
Tere, 2. matkaja!
Tere, 3. matkaja!
Tere, 4. matkaja!
Tere, 5. matkaja!
Järelkontroll
Nii for-i kui while puhul kontrollitakse alati ploki algul, kas seda on vaja täita. Ning kui matkajate 
arv poleks mitte 5, vaid hoopis 0, siis sellisel juhul ei täideta plokki ainsatki korda, ehk kõik tered 
jäävad ütlemata. Mõnikord on aga teada, et plokk tuleb kindlasti läbida. Lihtsalt pole teada, kas 
sama teed tuleb ka teist või kolmandat korda käia. Tüüpiline näide selle juures on sisestuskontroll. 
Kui esimene kord toiming õnnestus, pole vaja kasutajalt andmeid uuesti pärida. Juhtus aga äpardus, 
siis tuleb senikaua  jätkata, kuni kõik korras on. Siin küsitakse jälle tunninäitu. Sattus see 
arusaadavase vahemikku, minnakse  rahus  uue väärtusega edasi. Kui aga midagi ebaõnnestus, siis on 
arvuti väga järjekindel uuesti ja uuesti küsima lootuses, et kunagi ka midagi temale sobilikku 
jagatakse.
using System;
public class Kordus3{
   public static void Main(string[] arg){
      int tund;
      do{
         Console.WriteLine(" Sisesta tund vahemikus 0-23");
         tund=int.Parse(Console.ReadLine());
      } while(tund23);
      Console.WriteLine("Tubli, sisestasid {0}.", tund);
   }
}
/*
D:\kodu\0606\opikc#>Kordus3
Sisesta tund vahemikus 0-23

32
Sisesta tund vahemikus 0-23
11
Tubli, sisestasid 11.
*/

Ülesandeid
* Trüki arvude ruudud ühest kahekümneni
* Küsi kasutajalt viis arvu ning väljasta nende summa
* Ütle kasutajale "Osta  elevant  ära!". Senikaua korda küsimust, kuni kasutaja lõpuks ise kirjutab 
"elevant". 
Korrutustabel
... ehk näide, kuidas eelnevalt vaadatud tarkused ühe programmi sisse kokku panna ning mis selle 
peale ka midagi tarvilikku teeb.
Algul on näha, kuidas otse programmi käivitamise juures ka mõned andmed sinna kätte anda. Et kui 
kirjutan
Korrutustabel 4 5
siis saadakse sellest aru, et soovin korrutustabelit nelja rea ja viie veeruga. Nende käsurea 
parameetrite püüdmiseks on alamprogramm Main-i ümarsulgudes koht string[] argumendid. 
Kõik käsureale kirjutatud sõnad (ka üksik number on arvuti jaoks sõna) pannakse sinna 
argumentide massiivi ehk jadasse, kust neid järjekorranumbri järgi kätte saab. Andmetüüp 
string[] tähendabki, et tegemist on stringide ehk sõnede ehk tekstide massiiviga. Kirjutades 
massiivi järgi . Length , saab teada, mitu elementi selles massiivis on - mis praegusel juhul on 
võrdne lisatud sõnade arvuga käsureal. Kõik sõnad saab ka ükshaaval järjekorranumbri järgi kätte. 
Arvestama peab ainult, et sõnu hakatakse lugema  numbrist  0. Nii et kui eeldatakse, et tegemist on 
kahe parameetriga, siis nende kättesaamiseks peame ette andma  numbrid  null ja üks. 
Nagu tingimusest on näha: juhul kui argumente pole täpselt kaks, siis kasutatakse vaikimisi ridade 
ja veergude arvu ning joonistatakse korrutustabel suurusega 10 korda 10.
Tabeli trükkimiseks on kaks for-tsüklit paigutatud üksteise sisse. Selles pole midagi imelikku - iga 
rea juures trükitakse kõik  veerud esimesest  kuni viimaseni. Ning selleks, et erinevate  numbrite  
arvuga arvud meie tabelit sassi ei lööks, on väljatrüki juurde vorminguks kirjutatud {0, 5}. Ainsat 
Console.Write argumenti (järjekorranumbriga 0) trükitakse nõnda, et ta võtaks alati viis kohta.
using System;
class Korrutustabel{
   public static void Main(string[] argumendid){
      int ridadearv=10, veergudearv=10;
      if(argumendid.Length==2){
         ridadearv=int.Parse(argumendid[0]);
         veergudearv=int.Parse(argumendid[1]);
      }
      for(int rida=1; ridaKorrutustabel 4 5
    1    2    3    4    5
    2    4    6    8   10
    3    6    9   12   15
    4    8   12   16   20
*/
Alamprogramm
Nii nagu algul kirjas, nii ka siin tasub meeles pidada, et programmid armastavad paisuda ja paisuda. 
Seepärast tuleb leida mooduseid, kuidas üha suuremaks kasvavas koodihulgas orienteeruda. 
Alamprogramm on esmane ja hea vahend koodi sisse uppumise vältimiseks. Lisaks võimaldab ta 
terviklikke tegevusi eraldi ning mitu korda välja kutsuda. Samuti on ühe alamprogrammi tööd 
küllalt hea testida. Järgnevalt võimalikult lihtne näide, kuidas omaette tegevuse saab 
alamprogrammiks välja tuua. Siin on selliseks  tegevuseks  korrutamine . Luuakse käsklus nimega 
Korruta , talle antakse ette kaks täisarvu nimedega arv1 ja arv2 ning välja  oodatakse  sealt ka  tulema  
täisarv. 
using System;
class Alamprogramm{
   static int Korruta(int arv1, int arv2){
      return arv1*arv2;
   }
   public static void Main(string[] arg){
      int a=4;
      int b=6;
      Console.WriteLine("{0} korda {1} on {2}", a, b, Korruta(a, b));
      Console.WriteLine(Korruta(3, 5));
   }
}
/*
C:\Projects\oma\naited>Alamprogramm

4 korda 6 on 24
15
*/
Ülesandeid

* Koosta  alamprogramm kahe arvu keskmise leidmiseks
* Koosta alamprogramm etteantud arvu tärnide väljatrükiks. Katseta .
* Küsi inimeselt kolm arvu. Iga arvu puhul joonista vastav kogus tärne ekraanile
Massiivid
Kuna arvuti on mõeldud suure hulga andmetega ümber käimiseks, siis on programmeerimiskeelte 
juurde mõeldud ka vahendid nende andmehulkadega toimetamiseks. Kõige lihtsam ja levinum neist 
on massiiv . Iga elemendi poole saab tema järjekorranumbri abil pöörduda. Algul tuleb määrata, 
millisest  tüübist andmeid massiivi pannakse ning mitu kohta elementide jaoks massiivis on. 
Järgnevas näites tehakse massiiv kolme täisarvu hoidmiseks. Kusjuures  nagu C-
programmeerimiskeele sugulastele kombeks on, hakatakse elemente lugema nullist. Nii et kolme 
massiivielemendi puhul on nende järjekorranumbrid 0, 1 ja 2. Tahtes väärtusi sisse kirjutada või 
massiivist lugeda, tuleb selleks kirja panna massiivi nimi (praeguse juhul m) ning selle taha 
kandiliste  sulgude  sisse järjekorranumber, millise elemendiga suhelda tahetakse.
using System;
class Massiiv1{
   public static void Main(string[] arg){
      int[] m=new int[3];
      m[0]=40;
      m[1]=48;
      m[2]=33;
      Console.WriteLine(m[1]);
   }
}
/*
C:\Projects\oma\naited>Massiiv1

48
*/
Tsükkel andmete kasutamiseks

Massiivi kõikide elementidega kiiresti suhtlemisel aitab tsükkel. Siin näide, kuidas arvutatakse 
massiivi elementidest summa. Algul võetakse üks abimuutuja nulliks ning siis liidetakse kõikide 
massiivi elementide väärtused sellele muutujale juurde.  Avaldis  summa+=m[i] on pikalt lahti 
kirjutatuna summa=summa+m[i] ning tähendab just olemasolevale väärtusele otsa liitmist. for-
tsükli juures kõigepealt võetakse  loendur (sageli kasutatakse tähte i) algul nulliks, sest nullist 
hakatakse massiivi elemente lugema. Jätkamistingimuses kontrollitakse, et on veel läbi käimata 
elemente ehk loendur on väiksem kui massiivi elementide arv (massiivinimi.Length). Pärast iga 
sammu suurendatakse loendurit (i++). Nõnda ongi summa käes.
using System;
class Massiiv2{
   public static void Main(string[] arg){
      int[] m=new int[3];
      m[0]=40;
      m[1]=48;
      m[2]=33;
      int summa=0;
      for(int i=0; iMassiiv2

121
*/
Massiiv ja alamprogramm

Nagu ennist kirjutatud, saab eraldiseisva toimingu kergesti omaette alamprogrammi tuua. Siin on 
nõnda eraldatud summa leidmine. Massiive saab alamprogrammile samuti ette anda nagu tavalisi 
muutujaid. Lihtsalt andmetüübi taga on kirjas massiivi tunnusena kandilised sulud. 
using System;
class Massiiv3{
   static int LeiaSumma(int[] mas){
      int summa=0;
      for(int i=0; iMassiiv3

121
*/
Algväärtustamine, järjestamine

Kui massiivi elementide väärtused on kohe massiivi loomise ajal teada, siis saab nad loogelistes 
sulgudes  komadega  eraldatult kohe sisse kirjutada. Nii saab andmed lihtsalt lühemalt kirja panna. 
Kui elemendid on lihtsa võrdlemise teel järjestatavad nagu näiteks täisarvud, siis piisab nende 
rittaseadmiseks klassi  Array  ainsast käsust Sort.
using System;
class Massiiv4{
   public static void Main(string[] arg){
      int[] m=new int[3]{40, 48, 33};
      Array.Sort(m);
      for(int i=0; iMassiiv4

33
40
48
*/
Osutid ja  koopiad

Kui ühe  hariliku  täisarvulise muutuja väärtus omistada teisele, siis mõlemas muutujas on koopia 
samast  väärtusest ning toimingud ühe muutujaga teise väärtust ei mõjuta. Massiividega ning 
tulevikus ka muude objektidega tuleb tähelepanelikum olla. Kui üks massiiv omistada teisele, siis 
tegelikult kopeeritakse vaid massiivi osuti, mõlema muutuja kaudu pääsetakse ligi tegelikult 
samadele andmetele. Nagu järgnevas näites: massiivid m2 ja m näitavad samadele andmetele. Kui 
ühe muutuja kaudu andmeid muuta, siis muutuvad ka teise muutuja kaudu nähtavad andmed nagu 
väljatrüki juures paistab. Algselt on massiivi m ja m2 elemendid 40, 48, 33. Pärast massiivi m 
elemendi number 1 muutmist  32ks, on ka massiivi m2 elemendid muutunud - väärtusteks 40, 32, 33. 
Nõnda on suurte andmemassiivide juures teise muutuja tegemine andmete juurde pääsemiseks 
arvuti jaoks kerge ülesanne. Samas aga peab vaatama, et vajalikke andmeid kogemata 
ettevaatamatult ei muudaks. 
      int[] m=new int[3]{40, 48, 33};
      int[] m2=m; // Viide samale massiivile
      Tryki(m2);
      m[1]=32;
      Tryki(m2);
Kui soovida, et kaks algsetest andmetest pärit massiivi on üksteisest sõltumatud, siis tuleb teha 
algsest massiivist koopia (kloon).
      int[] m3=(int[])m.Clone(); //Andmete koopia
      m[1]=20;
      Tryki(m3);
Pärast kloonimist muutused massiiviga m enam massiivi m3 väärtusi ei mõjuta. 
Soovides massiivi tühjendada, aitab klassi Array käsklus  Clear , mis täisarvude puhul kirjutab 
etteantud vahemikus (ehk praegusel juhul kogupikkuses, 0 ja Length-i vahel) täisarvude puhul 
väärtusteks  nullid
      Array.Clear(m3, 0, m3.Length); //Tühjendus
Massiivist andmete otsimiseks sobib käsklus IndexOf. Soovitud elemendi leidumise korral 
väljastatakse selle elemendi järjekorranumber. Otsitava puudumisel aga -1.
      Console.WriteLine(Array.IndexOf(m,33));
      Console.WriteLine(Array.IndexOf(m,17)); // puuduv element
using System;
class Massiiv5{
   static void Tryki(int[] mas){
      for(int i=0; iMassiiv5

40
48
33
40
32
33
40
32
33
0
0

0

2
-1
*/
Massiiv alamprogrammi parameetrina

Massiivimuutuja omistamisel tekib võimalus kahe muutuja kaudu samadele andmetele ligi pääseda. 
See võimaldab luua alamprogramme, mis massiivi elementidega midagi peale hakkavad. Eelnevalt 
vaadeldud käsklus Sort tõstab massiivis elemendid kasvavasse järjekorda. Siin on näha omatehtud 
alamprogramm KorrutaKahega, mis massiivi kõikide elementide väärtused kahekordseks 
suurendab. 
using System;
class Massiiv6{
   static void KorrutaKahega(int[] mas){
      for(int i=0; iMassiiv7

40
48
33
*/
Mitmemõõtmeline massiiv

Massiivis võib mõõtmeid olla märgatavalt rohkem kui üks. Kahemõõtmelist massiivi saab ette 
kujutada tabelina, milles on read ja veerud. Kolmemõõtmelise massiivi elemendid oleksid nagu 
tükid  kuubis , mille asukoha saab määrata pikkuse, laiuse  ja kõrguse kaudu. Harva läheb vaja enam 
kui kolme mõõdet - siis on sageli juba otstarbekam ja arusaadavam oma andmestruktuur ehitada. 
Kasutamine toimub aga nii, nagu allpool näites näha. Massiivi elementidega saab ümber käia nagu 
tavaliste  muutujatega.  foreach -tsükliga saab soovi korral läbi käia ka mitmemõõtmelise massiivi 
kõik elemendid.
using System;
class Massiiv8{
   public static void Main(string[] arg){
      int[,] m=new int[2,3]{
         {40, 48, 33},
         {17, 23, 36}
       };
      Console.WriteLine(m[0, 1]); //48
      Console.WriteLine("M66dete arv: "+m. Rank );
      Console.WriteLine("Ridade arv: "+m.GetLength(0));
      Console.WriteLine("Veergude arv: "+m.GetLength(1)); 
                              //elemente mõõtmes nr. 1
      int summa=0;
      foreach(int arv in m){
        summa+=arv;
      }
      Console.WriteLine("Summa: "+summa);
   }
}
/*
C:\Projects\oma\naited>Massiiv8

48
M66dete arv: 2
Ridade arv: 2
Veergude arv: 3
Summa: 197
*/

Ülesandeid
* Küsi kasutaja käest viis arvu ning väljasta need tagurpidises järjekorras.
* Loo alamprogramm massiivi väärtuste aritmeetilise keskmise leidmiseks. Katseta.
* Loo alamprogramm, mis suurendab kõiki massiivi elemente ühe võrra. Katseta.
* Sorteeri massiiv ning väljasta selle keskmine element.
* Koosta kahemõõtmeline massiiv ning täida korrutustabeli väärtustega. Küsi massiivist 
kontrollimiseks väärtusi.
Käsud mitmes  failis
Suuremate programmide puhul on täiesti loomulik, et kood jagatakse mitme faili vahel. Nii on hea 
jaotuse puhul kergem orienteeruda. Samuti on mugav terviklike tegevuste plokke muudesse 
programmidesse ümber tõsta, kui see peaks vajalikuks osutuma. Siin näites on kaks lihtsat 
arvutustehet omaette abivahendite klassis välja toodud.
class Abivahendid {
   public static int korruta(int a, int b){
      return a*b;
   }
   
   public static int liida(int a, int b){
      return a+b;
   }
}
Abivahendeid kasutav alamprogramm asub aga hoopis eraldi klassis ja failis. 
using System;
class Abivahendiproov{
   public static void Main(string[] arg){
      Console.WriteLine(Abivahendid.korruta(3, 6));
   }
}
Kui tahta, et kompilaator vajalikud osad üles leiaks, tuleb kompileerimisel ette anda kõikide 
vajaminevate failide nimed. 
C:\Projects\oma\naited>csc Abivahendid.cs Abivahendiproov.cs
Microsoft (R) Visual C# 2005 Compiler version 8.00.50727.42
for Microsoft (R) Windows (R) 2005 Framework version 2.0.50727
Copyright (C) Microsoft Corporation 2001-2005. All rights reserved.
Lõpliku, exe-faili nimi määratakse vaikimisi faili järgi, kus oli kirjas 
Main-meetod.
C:\Projects\oma\naited>Abivahendiproov

18
Ülesandeid

* Lisa käsklus täisarvude astendamiseks tsükli abil. Katseta
* Lisa kolmas fail paari tärnidest kujundeid joonistava funktsiooniga. Katseta peaprogrammis 
mõlema abifaili funktsioonide väljakutseid.
Tekst
Teksti koostamise, analüüsimise ja muutmisega puutuvad kokku enamik arvutiprogramme. 
Järgnevalt mõned näited, mille põhjal saab enamiku vajalikke tekstiga seotud toimetusi korda.
Teksti pikkuse saab kätte muutujast Length. Loetakse kokku kõik tekstis leiduvad sümbolid, 
kaasaarvatud tühikud.
Tekstist lõigu eraldamiseks sobib  Substring . Esimese parameetrina olev arv näitab, mitmendast 
tähest hakatakse andmeid võtma, teine näitab, mitu tähte võetakse. String ehk sõne algab tähega 
number 0. Nii  lugedes  ongi sõna "tuli" algustäht järjekorranumbriga 5.
IndexOf võimaldab tekstis tähte või sõna leida. Leidmise korral väljastatakse leitud jupi algustähe 
järjekorranumber. Otsitava puudumise tulemusena väljastatakse -1.
using System;
class Tekst1{
  public static void Main(string[] arg){
    string s="Juku tuli kooli";
    Console.WriteLine("Pikkus: "+s.Length);
    Console.WriteLine(s.Substring(5, 4));
    Console.WriteLine("'tuli' kohal "+s.IndexOf("tuli"));
  }
}
/*
C:\Projects\oma\naited>Tekst1
Pikkus: 15
tuli
'tuli' kohal 5
*/
Muutmine
Teksti muutmiseks sobivad käsud  Insert  ja  Remove . Esimene lisab soovitud kohale juurde 
etteantud teksti. Lausest "Juku tuli kooli" sai üheksandale kohale sõna " vara" lisamisel lause "Juku 
tuli vara kooli". Remove võimaldab sobivast kohast tähti välja võtta. Tehniliselt vaadates käsud 
Insert ja Remove ei muuda algses muutujas olevat teksti, vaid luuakse uus tekstiplokk mälus, mille 
poole on võimalik muutuja kaudu pöörduda. Muutujas s on endiselt "Juku tuli kooli". Vaid s2 ja s3 
on uute väärtustega.
Tekstiga ümber käimiseks on ka mitukümmend muud käsklust, millega lähemat tutvust teha saab 
veebiaadressilt  http://msdn2.microsoft.com/en-us/library/system.string_methods.aspx
Levinumatest on siin näha StartsWith alguse kontrolliks, IndexOf teksti otsinguks ja Replace 
asendamiseks. Aja jooksul läheb aga vaja tõenäoliselt meetodit  Compare  järjestuse kindlaks 
tegemisel, EndsWith lõpu kontrollimisel, Trim tühikute eemaldamisel, ToUpper ja ToLower suur- 
ja väiketähtedeks muutmisel ning ToCharArray juhul, kui soovitakse tervikliku teksti asemel 
tähemassiivi kasutada (näiteks tähtede massiliseks ümbertõstmiseks).
using System;
class Tekst2{
  public static void Main(string[] arg){
    string s="Juku tuli kooli";
    Console.WriteLine("Pikkus: "+s.Length);
    Console.WriteLine(s.Substring(5, 4));
    Console.WriteLine("'tuli' kohal "+s.IndexOf("tuli"));
    string s2=s.Insert(9, " vara");
    Console.WriteLine(s2);
    string s3=s.Remove(5, 5); //Kuuendast alates viis tähte
    Console.WriteLine(s3);
    if(s.StartsWith("Juku")){
       Console.WriteLine("Algab Jukuga");
    }
    if(s.IndexOf("kala")==-1){
       Console.WriteLine("Siin ei ole kala");
    }
    Console.WriteLine(s.Replace("tuli", "jooksis"));
  }
}
/*
C:\Projects\oma\naited>Tekst2
Pikkus: 15
tuli
'tuli' kohal 5
Juku tuli vara kooli
Juku kooli
Algab Jukuga
Siin ei ole kala
Juku jooksis kooli
*/
Tükeldamine
Pika teksti  osadeks  jaotamiseks on mitmetes keeltes olemas vastavad käsud ja objektid. Nii ka siin. 
Käsuga  Split  võib olemasoleva teksti määratud sümbolite koha pealt juppideks lõigata. Kõikidest 
üksikutest tükkidest moodustatakse massiiv. Siin näiteks on eraldajaks  koma , mis tähemassiivi 
üksiku elemendina ette antakse. Aga nagu aimata võib, saab massiivi lisada ka rohkem eraldajaid. 
Kui on põhjust massiiv uuesti üheks pikaks tekstiks kokku panna, siis selle tarbeks leiab käskluse 
Join .
using System;
class Tekst3{
  public static void Main(string[] arg){
    string s="Tallinn,Tartu,Narva";
    string[] linnad=s.Split(new char []{','});
    foreach(string linn in linnad){
       Console.WriteLine(linn);
    }
    Console.WriteLine(String.Join("; ", linnad));
  }
}
/*
D:\kodu\0606\opikc#>Tekst3
Tallinn
Tartu
Narva
Tallinn; Tartu; Narva
*/
Ülesandeid
* Trüki inimese nime eelviimane täht
* Teata, kas  sisestatud  nimi algab A-ga
* Trüki sisestatud nimi välja suurtähtedega
* Teata, kas lauses leidub sõna "ja"
* Asenda olemasolu korral "ja" sõnaga "ning" ja teata asendusest
* Trüki välja lause kõige pikem sõna
Tekstifailid
Kui samu lähteandmeid on vaja korduvalt kasutada, siis on neid igakordse sissetoksimise asemel 
mugavam sisse lugeda  failist . Samuti on suuremate andmemahtude korral hea, kui sisendi ja 
väljundi andmed jäävad alles ka masina väljalülitamise järel. Keerukama struktuuriga andmete ning 
mitme üheaegse kasutaja korral (näiteks veebirakendustes) kasutatakse enamasti andmebaasi. 
Käsurea- või iseseisva graafilise rakenduse puhul on tekstifail aga lihtne ja mugav moodus andmete 
hoidmiseks. Samuti on ta tarvilik juhul, kui juba pruugitakse eelnevalt  tekstifaili  kujul olevaid 
andmeid.
Kirjutamine
Andmete faili saatmiseks tuleb kõigepealt moodustada  voog etteantud nimega faili kirjutamiseks. 
Edasine trükk toimub juba sarnaselt ekraaniväljundiga Write ning WriteLine käskude abil. Lõppu 
tuleb kindlasti lisada käsklus  Close , et teataks hoolitseda andmete füüsilise kettale jõudmise eest 
ning antakse fail vabalt kasutatavaks ka ülejäänud programmide jaoks. Siinse näite tulemusena 
tekib käivituskataloogi lihtne fail nimega "inimesed.txt", kuhu kirjutatakse kaks nime. 
Tekstiekraanil enesel pole käivitamise järel midagi näha - aga see veel ei tähenda, nagu programm 
midagi ei  teeks . Lihtsalt tema töö tulemus jõuab loodavasse faili.
using System;
using System.IO;
class Failikirjutus{
  public static void Main(string[] arg){
            FileStream f = new FileStream("inimesed.txt", 
                            FileMode .Create, FileAccess.Write);
            StreamWriter valja = new StreamWriter(f);
            valja.WriteLine("Juku");
            valja.WriteLine("Kati");
            valja.Close();     
  }
}
Lisamine
Kui FileMode.Create  asendada  seadega FileMode.Append, siis jäävad kirjutades vanad andmed 
alles. Uued read lihtsalt lisatakse olemasoleva teksti lõppu. Sellist lisamist läheb tarvis näiteks 
sündmuste  logi  kirjutamise juures. 
using System;
using System.IO;
class Faililisamine{
  public static void Main(string[] arg){
            FileStream f = new FileStream("inimesed.txt", 
                             FileMode.Append, FileAccess.Write);
            StreamWriter valja = new StreamWriter(f);
            valja.WriteLine("Siim");
            valja.WriteLine(" Sass ");
            valja.Close();     
  }
}
Lugemine
Faili lugemisel on vood teistpidi. Create ja Write asemel on  Open  ja Read. Ning StreamWriteri 
asemel StreamReader. Voost tuleva iga ReadLine tulemusena antakse üks tekstirida failist. Kui 
faili andmed lõppesid, saabub ReadLine käsu tulemusena tühiväärtus null. Selle järgi saab 
programmeerija otsustada, et fail sai läbi. Tahtes faili keerukamalt töödelda - üksikute tähtede poole 
pöörduda või  tervikuna  ette võtta - selleks tuleb juba failiga seotud õpetusi ise lähemalt uurida. 
using System;
using System.IO;
class Faililugemine{
   public static void Main(string[] arg){
        FileStream f = new FileStream("inimesed.txt", 
                       FileMode.Open, FileAccess.Read);
        StreamReader sisse=new StreamReader(f);
        string rida=sisse.ReadLine();
        while(rida!=null){
           Console.WriteLine(rida);
           rida=sisse.ReadLine();
        }
   }
}
/*
C:\Projects\oma\naited>Faililugemine.exe
Juku
Kati
*/
Ülesandeid
* Tekita programmi abil fail, milles oleksid arvud ja nende ruudud ühest kahekümneni
* Tekstifaili igal real on müüdud kauba hind. Arvuta programmi abil nende hindade summa.
* Iga hinna kõrval on ka selle hinnaga müüdud kauba kogus. Korruta igal real hind kogusega ning 
liida lõpuks  summad kokku.
* Võrreldes eelmise ülesandega kirjuta teise faili igale reale esimese faili vastaval real oleva hinna 
ja koguse korrutis.
Juhuarv
Kui soovida, et arvuti  samade  algandmete abil erinevalt käituks, tulevad appi juhuarvud. Nende abil 
saab kasutajale ette anda juhusliku tervituse, muuta soovi järgi pildi värvi, või näiteks kontrollida 
loodud funktsiooni toimimist mitmesuguste väärtuste juures. Kõigi nende erinevate väljundite 
aluseks on arvuti poolt loodud juhuarvud. Neid aitab saada nimeruumi System klassi  Random  
eksemplarReaalarvu saamiseks on käsklus NextDouble. Kui soovida mõnda muud vahemikku kui 
nullist üheni, tuleb saadud arv lihtsalt soovitud suurusega läbi korrutada. Ühtlase jaotuse asemele 
normaal- või mõne muu jaotuse saamiseks tuleb mõnevõrra enam vaeva näha - juhul kui see peaks 
tarvilikuks osutuma.
Täisarv luuakse käsuga Next, andes ette ülempiiri, soovi korral ka  alampiiri . Ning sobiva nime, 
anekdoodi või terviku saamiseks tuleb  olemasolevad valitavad objektid paigutada massiivi, leida 
juhuarv massiivi elementide arvu piires ning võibki sobiva väärtuse välja võtta. 
using System;
public class Juhuarv1{
   public static void Main(string[] arg){
      Random r=new Random();
      Console.WriteLine(r.NextDouble()); //Nullist üheni
      Console.WriteLine(r.Next(20)); //Täisarv alla 20
      Console.WriteLine(r.Next(50, 100)); //Viiekümnest sajani
      string[] nimed={"Juku", "Kati", "Mati"};
      Console.WriteLine(nimed[r.Next(nimed.Length)]); //Juhuslik nimi
   }
}
/*
D:\kodu\0606\opikc#>Juhuarv1

0,74339002358885
11
95
Kati
*/
Ülesandeid

* Trüki juhuslike teguritega korrutamisülesanne
* Kontrolli, kas kasutaja pakutud vastus oli õige
* Sõltuvalt vastuse õigsusest lase  arvutil  pakkuda olemasolevate hulgast valitud kiitev või julgustav 
kommentaar.
Omaloodud andmestruktuur
Standardandmetüüpe on .NET raamistikus kätte saada palju. Klasside arvu loetakse tuhandetes. 
Sellegipoolest juhtub oma rakenduste puhul olukordi, kus tuleb toimetada andmetega, mille 
hoidmiseks mugavat moodust pole olemas. Või siis on keegi kusagil selle küll loonud, aga lihtsalt ei 
leia üles. Harilike  muutujate ja massiivide abil saab küll kõike arvutis ettekujutatavat hoida. Vahel 
aga on mugavam, kui pidevalt korduvate sarnaste andmete hoidmiseks luuakse eraldi andmetüüp. 
Siis on teada, et kokku kuuluvad andmed püsivad kindlalt ühes kohas koos ning pole nii suurt 
muret, et näiteks kahe firma andmed omavahel segamini võiksid minna.
Järgnevas näites kirjeldatakse selliseks omaette andmestruktuuriks punkt tasandil, kaks täisarvulist 
muutujat asukohti määramas.
    struct Punkt{
       public int x;
       public int y;
   }
Kui edaspidi programmis kirjutatakse 
Punkt p1
siis on teada, et p1-nimelisel eksemplaril on olemas x ja y väärtused ning neid on võimalik vaadata 
ja muuta. struct-iga kirjeldatud andmestruktuuri  põhjal loodud muutuja omistamisel teisele sama 
tüüpi muutujale kopeeritakse väärtused ilusti ära. Nii nagu ühe täisarvulise muutuja väärtuse 
omistamisel teisele tekib sellest arvust koopia uude mälupiirkonda, nii ka struktuurina loodud 




Punkti omistamisel teisele Punktile on mälus kaks eraldi ja sõltumatut piirkonda, mõlemal x-i ja y-i 
teise x-i ja y-iga samasugused. Õieti ei peakski sellist kopeerimist eraldi rõhutama - tundub ju 
nõnda omistamisel kopeerimine täiesti loomulik. Märkus on toodud lihtsalt tähelepanu äratamiseks. 
Kui tulevikus ei kasutata andmetüübi loomisel mitte sõna struct, vaid sõna class, siis käitutakse 
omistamisel mõnevõrra teisiti. 
Nüüd aga programmi töö kohta seletus.
         Punkt p1;  
Luuakse muutuja nimega p1. Tal on mäluväljad nii x-i kui y-i jaoks.
         p1.x=3;
         p1.y=5;
Väljadele antakse väärtused
Punkt p2=p1;  
 
Luuakse muutuja nimega p2. Ka  temal  on mäluväljad nii x-i kui y-i jaoks. Muutuja p1 x-i väärtus 
kopeeritakse muutuja p2 x-i väärtuseks ning samuti ka y-iga.  Praeguseks  on siis mälus kahte kohta 
kirjutatud kolm ning kahte kohta viis. Edasi muudetakse esimese punkti x- koordinaat  kaheks. Teise 
oma aga jääb endiselt kolmeks.


p1.x=2;
        
Et kui nüüd teise punkti koordinaadid välja trükkida, siis tulevad sealt rõõmsasti 3 ja 5.
         Console.WriteLine(p2.x+" "+p2.y);
Võrreldes varasemate näidetega on koodi juurde tekkinud sõna namespace. Varasemate väiksemate 
programmide puhul mõtles kompilaator neile juurde  nimetu  ja nähtamatu vaikimisi nimeruumi. Kui 
aga klasse või struktuure on rohkem, on viisakas koos kasutatavad klassid teise nimeruumi 
eraldada. Sel juhul pole nii palju karta , et keegi teine oma klassid meie omadega sarnaselt nimetaks 
ning nad meie omadega tülli läheksid. Kui ka klassi nimi juhtub sama olema, aga nimeruum on 
erinev, siis saab kompilaator aru, et need on erinevad ning ei sega üksteist.
Töötav kood tervikuna.
using System;
namespace Punktid{
   struct Punkt{
       public int x;
       public int y;
   }
   class Punktiproov{
     public static void Main(string[] arg){
         Punkt p1;
         p1.x=3;
         p1.y=5;
         Punkt p2=p1;  //Väärtused kopeeritakse
         p1.x=2;
         Console.WriteLine(p2.x+" "+p2.y);
     }
   }
}
/*
C:\Projects\oma\naited>Punktid

3 5
*/
Punktimassiiv

Oma andmetüüpi on enamasti põhjust luua juhul, kui seda tüüpi andmeid on rohkem kui paar-kolm 
eksemplari. Suurema hulga samatüübiliste andmete jaoks kasutatakse sageli massiivi. Nii ka 
omaloodud andmetüübi puhul. 
         Punkt[] pd=new Punkt[10]; 
teeb punktidest kümme eksemplari järjenumbritega nullist üheksani. Ning ilusti järjenumbri järgi 
elemendi poole pöördudes saab sinna nii väärtusi panna kui küsida. Tsükli abil pannakse iga 
elemendi y väärtuseks tema järjekorranumbri ruut. Ning väljatrükil
         Console.WriteLine(pd[4].y);
trükitakse rõõmsasti ekraanile 16.
using System;
namespace Punktid2{
   struct Punkt{
       public int x;
       public int y;
   }
   class Punktimassiiv{
     public static void Main(string[] arg){
         Punkt[] pd=new Punkt[10]; //mälu kohe olemas
         for(int i=0; iPunktid2

16
*/
Ülesandeid

* Koosta struktuur riidelappide andmete hoidmiseks: pikkus, laius, toon
* Katseta loodud andmetüüpi paari eksemplariga.
* Loo lappidest väike massiiv, algväärtusta juhuarvude abil.
* Trüki välja lappide andmed, mille mõlemad küljepikkused on vähemalt 10 cm.
Edasijõudnute osa:  Objektorienteeritud   programmeerimine  
Tutvustus
struct - lausega loodud kirjed on mõeldud põhiliselt andmete hoidmiseks ning vajadusel üksikute 
andmete (nt. sünniaasta abil vanuse) välja arvutamiseks. Toimingud andmetega jäävad enamjaolt 
kirjest väljapool paikneva programmi ülesandeks. Objektide puhul aga püütakse enamik konkreetse 
objektitüübiga seotud  toiminguid ühise kesta sisse koondada. Piir  kirjete  ja objektide vahel on 
mõnevõrra hägune ning mõnes keeles (nt. Java ) polegi kirjete jaoks eraldi keelekäsklust olemas. 
Samas on siiski hea eri lähenemised lahus hoida. 
Traditsioonilise objektorienteeritud programmeerimise juures pole eksemplari muutujatele sugugi 
võimalik otse väljastpoolt ligi saada. Samuti on vaid mõned  alamprogrammid  teistele objektidele 
vabalt kasutavad, küllalt palju vahendeid võib olla loodud vaid objekti enese toimimise tarbeks. 
Selline  kapseldamine  aitab suuremate programmide puhul järge pidada, et vaid ühe  teemaga  seotud 
ning teemadevahelised lõigud üksteist  segama  ei  hakkaks . Lisaks väliste käskude vähemast arvust 
tulevale lihtsusele lubab muutujate ja alamprogrammide  varjamine  teiste objektide eest hiljem oma 
objekti sisemist ülesehitust muuta ilma, et muu programmi osa sellest häiritud saaks. Selline 
muutmisvõimalus on aga hästi tänuväärne olukorras, kus  tegijaid on palju, ja samu objekte 
kasutatakse tulevikus teisteski programmides.
Järgnevas näites on punkt loodud klassina ehk objektitüübina. Koordinaadid x ja y on privaatse 
ligipääsuga, neid saab kasutada vaid sama klassi meetodites. Väärtuste küsimiseks on eraldi 
käsklused  GetX  ja  GetY . Esimese hooga võib tunduda selline väärtuse küsimise  peitmine  imelik. 
Aga kui tulevikus näiteks soovitakse teha statistikat, et mitu korda on küsitud x-i ja mitu korda y-i 
väärtust, siis alamprogrammiga andmete küsimise puhul saab selle loenduse kergesti paika panna. 
Muutuja puhul aga ei ole nõnda tavaprogrammeerimise vahenditega võimalik. Kuna siin on lubatud 
punkti asukoha määramine vaid eksemplari loomisel, siis kord antud väärtusi enam muuta ei saa, 
sest Punkti juures pole lihtsalt vastavat käsklust. Klassiga samanimelist väljastustüübita käsklust 
nimetatakse konstruktoriks. See käivitatakse vaid üks kord - eksemplari loomisel - ning sinna sisse 
pannakse tavaliselt algväärtustamisega seotud toimingud. Kui näiteks algväärtustamisel seada sisse 
piirang, et koordinaatide väärtused peavad jääma nulli ja saja vahele, siis pole võimalik muus 
piirkonnas punkti luua. Sedasi õnnestub objektina luua küllalt keerukaid süsteeme, mis oskavad 
" iseenese  eest hoolitseda" ning millel saab lihtsalt käsklusi ehk meetodeid  välja kutsuda. 
using System;
namespace Punktid3{
   class Punkt{
       private int x;
       private int y;
       public Punkt(int ux, int uy){
         x=ux; y=uy;
       }
       public int GetX(){
         return x;
       }
       public int GetY(){
         return y;
       }
       public double KaugusNullist(){
         return Math . Sqrt (x*x+y*y);
       }
   }
   class Punktiproov{
     public static void Main(string[] arg){
         Punkt p1=new Punkt(3, 4);
         Console.WriteLine(p1.GetX());
         Console.WriteLine(p1.KaugusNullist());
     }
   }
}
/*
D:\kodu\0606\opikc#>Punktid3

3
5
*/
Ülesandeid

* Koosta klass riidelapi andmete hoidmiseks: pikkus, laius, toon
* Lisa käsklus lapi andmete väljatrükiks
* Lisa käsklus lapi pindala arvutamiseks
* Lisa meetod (alamprogramm) lapi poolitamiseks: pikem külg tehakse poole lühemaks.
* Poolitamise meetod lisaks algse lapi poolitamisele väljastab ka uue samasuguse algsest poole 
väiksema eksemplari.
* Lisa teine poolitusmeetod, kus saab määrata, mitme protsendi peale lõigatakse pikem külg
Klassimuutuja
Klassi juurde korjatakse võimalusel kokku kõik vastavat tüüpi objektidega tehtavad toimingud ja 
andmed. Enamasti kuuluvad andmed isendite ehk eksemplaride juurde, kuid mitte alati. Näiteks 
tüüpiliselt - loodud punktide arvu loendur on küll punktidega sisuliselt seotud, kuid pole sugugi ühe 
konkreetse punkti omadus. Punktide arv on olemas ka juhul, kui ühtegi reaalset punkti eksemplari 
pole veel loodud. Sellisel juhul on punktide arv lihtsalt null. Samuti on punktide arv olemas juhul, 
kui punkte on loodud palju. Lihtsalt sel juhul on loenduri väärtus suurem. Sellise klassi ja mitte 
isendiga seotud muutuja ette pannakse sõna static.
       static int loendur=0;
Teine asi on punkti järjekorranumber - see on iga punkti juures kindel arv, mis antakse punktile 
tema loomise hetkel ning mida siinse programmi puhul enam hiljem muuta ei saa. 
       private int nr;
       nr=++loendur;
tähendab, et kõigepealt suurendatakse loendurit (olemasolevate punktide arvu) ühe võrra ning 
saadud arv pannakse uue loodud punkti järjekorranumbriks. 
Osuti, omistamine
Klassi eksemplaride puhul toimub omistamine teisiti kui struktuuri eksemplaride puhul. Struktuuri 
juures tehti lihtsalt väljade väärtustest koopia ja edasi elas kumbki eksemplar oma elu teisest 
sõltumata. Kui nüüd aga teha omistamised
         Punkt p1=new Punkt(3, 4);
         Punkt p2=p1; //Kasutab sama mälupiirkonda
siis on mälus tegelikult koht vaid ühe punkti andmete jaoks, muutujate p1 ning p2 kaudu pääseb 
lihtsalt ligi samadele andmetele.
 Nii et kui ühe muutuja kaudu andmeid muuta:
         p1.SetX(7);         
siis muutuvad andmed ka teise märksõna alt paistvas vaates. 
Ehk siis ükskõik, kas andmete poole pöörduda p1 või p2 kaudu – ikka saan tegelikult samad 
väärtused. 
         Console.WriteLine(p2. GetNr ()+" "+p2.GetX()+" "+p2.GetY());
trükib välja 
         1 7 4
ehkki esialgu olid koordinaatideks 3 ja 4 ning p2 kohe deklareerimisel polnud sugugi algne koht 
esimese punkti andmetele ligi pääsemiseks.
Punkt järjekorranumbriga 2 on alles p3, sest tema loomisel käivitati uuesti Punkti konstruktor – 
loodi uus eksemplar, mille käigus suurendati loendurit ning anti uued kohad andmete mälus 
hoidmiseks. 
Nüüd siis eelnevate seletuste kood tervikuna.
using System;
namespace Punktid4{
   class Punkt{
       static int loendur=0;
       private int nr;
       private int x;
       private int y;
       public Punkt(int ux, int uy){
         x=ux; y=uy;
         nr=++loendur;
       }
       public int GetX(){
         return x;
       }
       public int GetY(){
         return y;
       }
       public int GetNr(){
         return nr;
       }
       public void SetX(int ux){
         x=ux;
       }
       public void SetY(int uy){
         y=uy;
       }
       public double KaugusNullist(){
         return Math.Sqrt(x*x+y*y);
       }
   }
   class Punktiproov{
     public static void Main(string[] arg){
         Punkt p1=new Punkt(3, 4);
         Punkt p2=p1; //Kasutab sama mälupiirkonda
         p1.SetX(7);         
         Console.WriteLine(p2.GetNr()+" "+p2.GetX()+" "+p2.GetY());
         Punkt p3=new Punkt(77, 32); //Punkt järgmise järjekorranumbriga
         Console.WriteLine(p3.GetNr());
     }
   }
}
/*
C:\Projects\oma\naited>Punktid4

1 7 4
2
*/
Punktimassiiv

Nii nagu üksiku muutuja juures, nii ka massiivi puhul tuleb (erinevalt structist) igale uuele klassi 
eksemplarile new-käsuga mälu anda.
         Punkt[] pd=new Punkt[10];
loob vaid kümme mälupesa, mis on võimelised näitama Punkt-tüüpi  objektile . Samas punktiobjekte 
pole selle käsu peale veel ühtegi. Ehk kui keegi sooviks näiteks pd[3] olematu eksemplariga midagi 
teha, siis antaks  veateade .
Alles siis, kui tsüklis luuakse iga ringi juures uus Punkti eksemplar ning pannakse massiivi element 
sellele näitama, on võimalik iga massiivi elemendiga kui Punkti eksemplariga ringi käia. 
         for(int i=0; i isikukoodi viimane number peab olema
üheksa.
Dokumenteerivad kommentaarid
Dokumentatsiooni loomiseks on üks võimalus panna kolme kaldkriipsuga märgistatud 
kommentaarid koodi sisse, kommenteeritava ploki või muutuja ette. Sellised kommentaarid oskab 
kompilaator sobiva võtme järgi välja, eraldi kommentaaride faili korjata. Kommentaariks  sobib 
xml-märgenditega piiratud tekst. Tavalisimaks  elemendiks  on , kuid eraldi on olemas ka 
kokkuleppelised käsklused parameetrite, versioonide jm. jaoks. 
Readonly
Võtmesõna readonly muutuja ees tähendab, et sinna võib väärtuse omistada vaid ühe korra. Olgu 
siis muutuja kirjeldamisel või konstruktoris. Selliste muutujate puhul hoolitseb juba kompilaator, et 
poleks võimalik kirjutada käsklusi, mis readonlyga kaitstud mäluväljade väärtusi muudavad.
Näide
using System;
namespace Punktid6{
   ///
   ///   Tasandi punkti andmete hoidmine
   ///
   class Punkt{
       ///
       ///    Muutuja ainult lugemiseks. 
       ///    Andmed sisestatavad vaid konstruktoris.
       ///
       private readonly int x;
       private readonly int y;
       ///
       ///    Algandmed punkti loomisel kindlasti vajalikud
       ///
       public Punkt(int ux, int uy){
         x=ux; y=uy;
       }
       public int GetX(){
         return x;
       }
       public int GetY(){
         return y;
       }
       ///
       ///   Kaugus arvutatakse Pythagorase teoreemi järgi.
       ///
       public double KaugusNullist(){
         return Math.Sqrt(x*x+y*y);
       }
   }
   ///
   ///    Eraldi klass punkti katsetamiseks.
   ///
   class Punktiproov{
     public static void Main(string[] arg){
         Punkt p1=new Punkt(3, 4);
         Console.WriteLine(p1.KaugusNullist());
     }
   }
}
Kompileerimine
Kompileerides saab siis /doc võtmega anda ette failinime, kuhu kirjutatakse kommentaarid. 
/*
D:\kodu\0606\opikc#>csc Punktid6.cs /doc:Punktid6.xml
Microsoft (R) Visual C# 2005 Compiler version 8.00.50727.42
for Microsoft (R) Windows (R) 2005 Framework version 2.0.50727
Copyright (C) Microsoft Corporation 2001-2005. All rights reserved.
D:\kodu\0606\opikc#>Punktid6

5
*/
Kommentaarifail

Edasi on juba vastavalt kasutaja soovile - kas ta loeb tekkinud XML-faili lihtsa tekstiredaktoriga, 
mõne eraldi XML-lugejaga (nt. vastavate võimetega veebibrauser) või siis kirjutab juurde XSL-lehe 
andmete omale sobivale kujule muundamiseks. 
Väike ülevaade tekkinud XML-failist. Esimene rida on ühine kõigile XML- vormingus  
dokumentidele.

Järgnevaks juurelemendiks on doc, mille sisse kõik ülejäänud andmed mahuvad.

Assembly  tähendab kokkukompileeritud üksust. Siin on ta laiendiks .exe, mõnel juhul võib olla aga 
ka .dll
   
        Punktid6
   
Ning edasi juba tulevadki klassi, muutuja, konstruktori ja meetodi töö kirjeldused.


   
        Punktid6
   
   
       
           
              Tasandi punkti andmete hoidmine
           
       
       
           
               Muutuja ainult lugemiseks. 
               Andmed sisestatavad vaid konstruktoris.
           
       
       
           
               Algandmed punkti loomisel kindlasti vajalikud
           
       
       
           
              Kaugus arvutatakse Pythagorase teoreemi jC¤rgi.
           
       
       
           
               Eraldi klass punkti katsetamiseks.
           
       
   

Ülesandeid
* Koosta klass riidelapi andmete hoidmiseks, lisa kommentaarid.
* Tutvu kompileerimisel loodud kommentaaride failiga. 
Pärilus
Ajapikku on objektorienteeritud programmeerimiskeelte juurde lisatud mitmesuguseid täiustusi ja 
võimalusi. Pärilus (inheritance) on mingil moel enamike objektorienteeritud keelte küljes olemas. 
Nii ka end suhteliselt arenenuks  keeleks  pidava C# juures.
Objektidega toimetamisel ning pärilusel sealhulgas on vähemalt kaks eesmärki. Püütakse 
lihtsustada koodi kohandamist. Samuti võimaldab pärilus vältida sama tööd tegeva koodi 
kopeerimist, lubades samu käsklusi kasutada mitmel pool.
Päriluse abil püütakse programmeerimiskeele objektitüüpide omavahelisi suhteid lähendada 
inimeste igapäevaselt tajutavale. Üheksakümnendate aastate algul ilmunud objektorienteeritud 
programmeerimist tutvustavas õpikus oli ilus näide: " sebra  on nagu hobune, kellel on triibud ". 
Sarnane  tuttava  kaudu uue tüübi kokkupanek ongi päriluse põhisisu. Midagi lisatakse, midagi 
muudetakse, vahel harva ka kaotatakse. Ning märkamatult muutubki hobune sebraks või tühi  paneel  
tekstiväljaks. 
Nõnda õnnestub olemasolevate (pool)valmis tükkide abil omale sobiv komplekt kokku panna. 
Teiselt  poolt võidakse objektide päriluspuu ehitada ka oludes, kus kõik programmi osad on enese 
määrata. Sellisel juhul pole küll eesmärk omale üks ja parim tüüp kokku panna, vaid otsitakse 
ühisosi, mille puhul on võimalik valminud tüübid  gruppidesse  jaotada ning nende gruppidega 
vajadusel koos midagi ette võtta. Tüüpilise näitena pole teatripiletit müües vaja teada inimese sugu 
ja ametit. Küll aga on balletirolli juures mõlemad andmed tähtsad. Tavaelus tundub loomulikuna, et 
eriomadusi arvestatakse vaid kohtades, kus need on vajalikud ning muul juhul aetakse vaid üldiste 
tunnustega läbi. Haruharva tuleb eraldi rõhutada, et "meie teatrisse tohivad vaatajaks tulla inimesed 
sõltumata usutunnistusest ja nahavärvist". Arvuti juures tuleb aga  tasemed selgelt välja tuua. Igal 
keerukuse astmel tuleb määrata, millised oskused ja omadused sinna juurde kuuluvad ning millise 
rolli jaoks millisel tasemel oskuste komplekti vaja on. Keerukaks kiskunud seletuste kõrvale 
selgitused näidete abil.
Päriluseta näide
Alustame inimese klassiga, kus igasugune pärilus puudub. Üks klass oma muutuja, konstruktori ja 
meetodiga ning testprogrammis saab tema võimalusi katsetada.
using System;
namespace Parilus1{
 class Inimene{
    protected int vanus;
   public Inimene(int uvanus){
      vanus=uvanus;
   }
   public void YtleVanus(){
      Console.WriteLine("Minu vanus on "+vanus+" aastat");
   }
 }
 class InimTest{
  public static void Main(string[] arg){
     Inimene inim1=new Inimene(13);
     inim1.YtleVanus();     
  }
 }
}
/*
C:\Projects\oma\naited>Parilus1
Minu vanus on 13 aastat
*/
Alamklass
Edasi juba juures inimese alamklass (subclass)  Modell , kel on olemas kõik inimese omadused (ehk 
siis selle programmi puhul võime oma  vanust  öelda), kuid juures käsklus enese esitlemiseks. Et 
esitlemine koosneb vanuse ja ümbermõõdu teatamisest, on see juba esitlemiskäskluse sisse 
kirjutatud.
Klass Inimene on  Modelli  suhtes ülemklassiks (superclass,  base  class,  parent  class). C# puhul on 
igal  klassil  alati täpselt üks ülemklass. Kui muud pole määratud, siis kasutatakse selleks vaikimisi 
nimeruumi System klassi  Object . Muul juhul aga on ülemklass kirjas klassikirjelduse päriluse osas. 
Nii tekibki klasside puu, mis algab  klassist  Object. 
Kui klassil konstruktor puudub, siis loob kompilaator vaikimisi tühja konstruktori, millel pole 
parameetreid ja mis ka midagi ei tee. Inimese puhul siis näiteks 
   public Inimene(){}
Kui aga vähemalt üks programmeerija loodud konstruktor on olemas, siis seda nähtamatut 
konstruktorit ei  tehta . Päriluse puhul kutsutakse alamklassi eksemplari loomisel alati välja 
ülemklassi konstruktor. Vaikimisi võtab kompilaator selleks ülemklassi parameetritega konstruktori. 
Kui see aga puudub või soovitakse käivitada mõnda muud, siis tuleb sobiva konstruktori väljakutse 
alamklassi juures ära märkida. Siin märgitakse näiteks Modelli loomise juures, et Modelli isendi 
loomise juures tehakse kõigepealt valmis baasklassi (inimese) isend , kellele siis Modelli enese 
konstruktoris vajalikud lisandused juurde pannakse. Ülemklassi konstruktori määramine on kohe 
Modelli konstruktori juures. Pärast koolonit olev base(vanus) ütleb, et kasutatagu inimese puhul 
seda konstruktorit, kus tuleb täisarvuline vanus kohe ette öelda. 
   public Modell(int vanus, int uymberm66t):base(vanus){
      ymberm66t=uymberm66t;
   }
Ehkki praegu tegelikult muud võimalust  polnudki , tuleb see ikkagi arvutile ette öelda.
using System;
namespace Parilus2{
 class Inimene{
   protected int vanus;
   public Inimene(int uvanus){
      vanus=uvanus;
   }
   public void YtleVanus(){
      Console.WriteLine("Minu vanus on "+vanus+" aastat");
   }
 }
 class Modell:Inimene {
   protected int ymberm66t;
   public Modell(int vanus, int uymberm66t):base(vanus){
      ymberm66t=uymberm66t;
   }
   public void Esitle(){
      YtleVanus();
      Console.WriteLine("Mu ymberm66duks on "+ymberm66t+" sentimeetrit ");
   }
 }
 class InimTest{
  public static void Main(string[] arg){
     Modell m=new Modell(20, 90);
     m.Esitle();
  }
 }
}
/*
C:\Projects\oma\naited>Parilus2
Minu vanus on 20 aastat
Mu ymberm66duks on 90 sentimeetrit
*/
Ülesandeid
* Lisa Inimesele pikkuse väli. 
* Pikkus tuleb sisestada konstruktoris sarnaselt vanusele. 
* Modelli käsklus Esitle teatab eraldi lausena ka pikkuse.
* Omista Modell Inimese tüüpi muutujale. Küsi sealtkaudu vanus.
* Koosta inimeste massiiv. Lisa sinna nii Modelle kui tavalisi inimesi. Küsi kõikide vanused.
* Lisa Inimesele int-tagastusväärtusega käsklus pikkuse väljastamiseks.
* Lisa testprogrammi käsklus static  bool  KasMahubAllveelaeva(Inimene isik), mis väljastab tõese 
väärtuse juhul, kui pikkust on alla 165 sentimeetri . Katseta käsku nii Inimese kui Modelli puhul, 
samuti Modellidest ja Inimestest koosneva massiivi juures.
* Väljasta  false -vastus ka null-sisendi korral. Allveelaeva luba ka kuni 170 sentimeetri pikkused 
modellid  (painduvad hästi, kontrolliks isik is Modell). 
* Loo mõlemale klassile taas ka ilma pikkuseta konstruktor. Sellisel juhul pannakse pikkuse 
väärtuseks -1 ning esitluse  juures teatatakse, et pikkuse andmed puuduvad.
Ülekate 
Mõnikord ei piirduta omaduste lisamisega - tahetakse olemasolevaid võimalusi ka muuta. 
Tavanäiteks on kujundid või graafikakomponendid, mis igaüks ennast vastavalt oma omadustele 
joonistavad. Aga sarnaselt üle kaetavad võivad olla voogudesse andmete kirjutamise käsklused või 
andmestruktuuridesse andmeid  lisavad  või sealt eemaldavad käsklused nii, et neid käsklusi kasutav 
programm võib lihtsalt kasutatavat tükki  usaldada , et tal on vastava nimega käsklus olemas ning ta 
selle soovitud ajal sooritab. 
Siin näites on Inimese alamklassiks tehtud  Daam , kel kõik muud kirjeldatud omadused hariliku 
Inimesega sarnased. Kuid vanuse ütlemine käib mõnevõrra teisiti. Et käske saaks rahus üle  katta
selleks on Inimese juurde käsu ehk meetodi YtleVanus ette lisatud sõna virtual, Daami vastava 
meetodi ette aga override. Selliselt on mõlemat tüüpi objektil vanuse ütlemine selge, need lihtsalt 
käituvad erinevalt.
using System;
namespace Parilus3{
 class Inimene{
   protected int vanus;
   public Inimene(int uvanus){
      vanus=uvanus;
   }
   public virtual void YtleVanus(){
      Console.WriteLine("Minu vanus on "+vanus+" aastat");
   }
 }
 class Daam:Inimene {
   public Daam(int vanus):base(vanus){}
   public override void YtleVanus(){
      Console.WriteLine("Minu vanus on "+(vanus-5)+" aastat");   
   }
 }
 class InimTest{
  public static void Main(string[] arg){
     Inimene inim1=new Inimene(40);
     Daam inim2=new Daam(40);
     inim1.YtleVanus();
     inim2.YtleVanus();
  }
 }
}
/*
C:\Projects\oma\naited>Parilus3
Minu vanus on 40 aastat
Minu vanus on 35 aastat
*/
Ülesandeid
* Lisa Inimesele käsklus "KutsuEttekandja", katseta seda eksemplari juures.
* Katseta sama käsklust ka Daami eksemplari juures.
* Kata nimetatud käsklus Daami juures üle, pannes sisse pidulikum ja peenem tekst. Katseta. 
* Loo Inimeste massiiv, kus on nii Inimesed kui  Daamid . Palu igaühel  teatada  oma vanus ning 
kutsuda ettekandja.
Liidesed
Nagu eespool kirjeldatud, on C# puhul üks ja kindel objektitüüpide pärinemise puu. Igal klassil on 
oma ülemklass ning juureks on klass Object nimeruumist System. Samas aga mõnegi tüübi puhul 
on sellest klassist objekte mugav kasutada tunduvalt rohkemates kohtades, kui otsene päriluspuu 
ette näeb. Nii nagu Ambla kihelkonna Lehtse valla Läpi küla Troska talu perepoeg Karl oli lisaks 
nendele ametlikele tiitlitele veel küla sepp, puutöömees ning korralik vanapoiss, nii on hea mõnegi 
klassi puhul programmi ülesehituse lihtsuse huvides pakkuda sinna rohkem rolle kui otsese päriluse 
järgi neid kokku tuleks. Näiteks  Karlal  oli leivateenimise mõttes sepatööst kindlasti rohkem kasu 
kui teatest, et ta Ambla kirikuraamatus kirjas on. Niisamuti  on klassidele võimalik juurde panna 
liideseid, mis annavad õiguse vastava klassi eksemplare kloonida, järjestada või muid kasulikke 
omadusi lisada.  Liideste  arv ühe klassi juures ei ole piiratud. Liidesed mõeldi 
programmeerimiskeelte juurde välja, kuna selgus, et nõnda kirjeldusi määrates ja kokku leppides 
õnnestub programmeerimisel vigu vähendada.
Järgnevas näites loodi liides IViisakas. I on liidesel ees sõnast  Interface . Liidese  juurde käib 
enamasti sisuline seletus selle kohta, millised seda liidest realiseerivad objektid on. Ning lisaks 
võivad olla mõned käsklused, millele vastavat liidest realiseerivad objektid on võimelised 
reageerima. Liidese IViisakas puhul valiti selliseks käskluseks Tervita, mis saab omale tekstilise 
parameetri. Ehk siis eeldatakse, et iga viisakas tegelane mõistab tervitusele vastata juhul, kui talle 
öeldakse, kellega on tegemist. Nagu näha - Lapse ja  Koera  puhul need tervitused on erinevad. Kuid 
nii nagu liides nõuab - nad on olemas. Sinnamaani suudab kompilaator kontrollida. Ülejäänu on 
juba programmeerija hoolitseda, et kindlaksmääratud nimega käskluse juurde ka vastavale klassile 
sobiv sisu saaks. 
  static void TuleSynnipaevale(IViisakas v){
     v.Tervita("vanaema");
  }
Loodud meetodi juures on näha, et parameetrina võetakse vastu vaid nende klasside eksemplare, 
kelle puhul liides IViisakas on realiseeritud. Ning igaühel neist palutakse  tervitada  vanaema. 
Kuidas keegi sellega hakkama saab, on juba klassi enese sees hoolitsetud.
using System;
namespace Liides1{
 class Inimene{
   protected int vanus;
   public Inimene(int uvanus){
      vanus=uvanus;
   }
   public virtual void YtleVanus(){
      Console.WriteLine("Minu vanus on "+vanus+" aastat");
   }
 }
 interface IViisakas{
   void Tervita(String tuttav);
 }
 class Laps:Inimene, IViisakas {
   public Laps(int vanus):base(vanus){}
   public void Tervita(String tuttav){
     Console.WriteLine("Tere, "+tuttav);
   }
 }
 class Koer: IViisakas{
   public void Tervita(String tuttav){
      Console.WriteLine("Auh!");
   }
 }
 class InimTest{
  static void TuleSynnipaevale(IViisakas v){
     v.Tervita("vanaema");
  }
  public static void Main(string[] arg){
     Laps juku=new Laps(6);
     juku.YtleVanus();
     Koer muki=new Koer();
     TuleSynnipaevale(juku);
     TuleSynnipaevale(muki);
  }
 }
}
/*
C:\Projects\oma\naited>Liides1
Minu vanus on 6 aastat
Tere, vanaema
Auh!
*/
Kui mingil põhjusel jäänuks Lapsele või Koerale käsklus Tervita lisamata, siis annaks kompilaator 
veateate. Sama tekiks ka juhul, kui käskluse tekstis trükiviga  tehtaks . Selline kompilaatoripoolne 
kontroll aitab vead üles leida juba enne tegelike andmetega katsetamise alustamist. 
Ülesandeid
* Katseta, mis juhtub, kui Lapse tervita kirjutada väikese tähega.
* Lisa liidesesse IViisakas käsklus KoputaUksele. 
* Muuda liidest realiseerivaid klasse nii, et kood kompileeruks.
* Testi töö tulemust.
* Koosta liides ISummeerija käsklustega Alusta, Lisa ning KysiSumma. Esimene siis tühjendab 
andmed, teine lisab ühe väärtuse ning kolmas väljastab olemasolevate summa.
* Koosta liidest realiseeriv klass, kus on muutuja summa hoidmiseks. Alustamise peale pannakse 
see nulli, lisamise puhul suurendatakse väärtust ning summa küsimisel väljastatakse meeles olev 
summa. Omista klassi eksemplar liidese tüüpi muutujale. Katseta.
* Koosta sama liidest realiseerima teine klass, kus lisatavate andmete jaoks on olemas massiiv. 
Kogu aeg peetakse meeles lisatud väärtuste arv ning väärtused ise. Summa küsimisel arvutatakse 
kokku elementide väärtuste summa ning väljastatakse see.
* Koosta eraldi peaprogramm, mis eeldab, et seal sees on kasutada ISummeerija liidest realiseeriv 
objekt – tegelikult aga algul on seal tühiväärtus-null. Peaprogramm koostatakse nõnda, et ta küsib 
kasutajalt arve ja palub ISummeerijal need kokku liita. Kontrolli, et kood kompileeruks.
* Koosta libasummeerija, mille Alusta ja Lisa-käsklused ei tee midagi. KysiSumma aga väljastab 
alati väärtuse -1. Katseta peaprogrammi loodud libaklassi objektiga.
* Loo eraldi klass SummeerijaVabrik summeerijaobjektide tootmiseks. Lisa sinna sisse staatiline 
käsklus LooSummeerija(int EeldatavKogus). Kui kogus on alla kümne, väljastatakse andmeid 
salvestav summeerija, muul juhul kohe andmeid kokku liitev summeerija. Katseta süsteemi 
toimimist.
Abstraktne  klass
Liideseid pidi pärinevad vaid meetodite nimed. Klasside kaudu pärinevad nimed koos sisuga. Aga 
mõnikord soovitakse vahepealset  varianti : et mõnedel meetoditel on olemas sisu, teistel aga veel 
mitte. Sellisel juhul aitab välja abstraktne klass. Tüüpiline näide on toodud allpool. Sirgete ja 
püstiste seintega kujundi puhul saab ruumala arvutada juhul, kui on teada põhja pindala ja kõrgus - 
valemi järgi piisab vaid nende omavahelisest korrutamisest. Kui aga kujundeid on palju, siis on niru 
seda valemit igale poole uuesti kirjutada. Rääkimata juhtudest, kus valem tunduvalt  keerukam  on, 
või neid iga kujundi kohta mitu. 
Siin on kujundi näidetena toodud  Tikutops  ja Vorstijupp. Esimesel neist on standardmõõtude 
puhul suurus kohe teada, vastavad meetodid väljastavad kohe konkreetsed arvud. Teisel juhul 
antakse mõõtmed objekti loomisel ette, meetodid peavad küsimise peale need salvestatud väärtused 
välja andma. Ning kui  vorst  ilusti matemaatiliselt omale silindrina ette kujutada, siis annab pii korda 
raadiuse ruut ilusti põhja ehk ristlõike pindala välja.
Klassist Kujund enesest ei saa eksemplare luua. Kui klass sisaldab abstraktseid ehk defineerimata 
meetodeid, siis peab klass ka ise tervikuna olema abstraktne ning siis ei lubata temast eksemplare 
teha. Muidu ju tekiks probleem, kui soovitaks käivitada kujundi olematu  koodiga  käsklust 
KysiKorgus(). 
Küll aga tohib muutujale tüübist Kujund tegelikke objekte omistada - olgu nad siis Tikutopsid, 
Vorstijupid või pärit mõnest  muust  Kujundi alamklassist. Sarnaselt nagu võis Daami omistada 
Inimese tüüpi muutujale või Lapse muutujale tüübist IViisakas. Kui üle kaetud klassis on 
eelnevalt abstraktsetele meetoditele sisu antud, siis võib sellest klassist julgesti isendeid luua ning 
neid ka kõikidest ülemklassidest pärit muutujatele omistada.
using System;
namespace AbstraktseKlassiUuring{
  abstract class Kujund{   
   public abstract double KysiPohjaPindala();
   public abstract double KysiKorgus();
   public double KysiRuumala(){
      return KysiPohjaPindala()*KysiKorgus();
   }
 }
 class Tikutops:Kujund{
   public override double KysiPohjaPindala(){return 8;}
   public override double KysiKorgus(){return 1.5;}
 }
   
 
 class Vorstijupp: Kujund{
   int pikkus, raadius;
   public Vorstijupp(int upikkus, int uraadius){
      pikkus=upikkus;
      raadius=uraadius;
   }
   public override double KysiPohjaPindala(){
     return Math.PI*raadius*raadius;
   }
   public override double KysiKorgus(){
     return pikkus;
   }
 }
 class Test{
   public static void Main(string[] arg){
      Tikutops t=new Tikutops();
      Vorstijupp v=new Vorstijupp(10, 3);
      Console.WriteLine("Ruumalad {0} ja {1}", 
                t.KysiRuumala(), v.KysiRuumala());
   }
 }
}
/*
D:\kodu\0606\opikc#>AbstraktseKlassiUuring
Ruumalad 12 ja 282,743338823081
*/
Ülesandeid
* Lisa klassile Kujund abstraktne meetod PohjaYmbermoot ning meetod KyljePindala. Katseta - 
lisades vajalikud meetodid ka alamklassidesse.
* Loo Kujundi alamklass  Risttahukas  lisades talle vajalikud väljad kolme mõõtme hoidmiseks ja 
kattes üles Kujundi abstraktsed meetodid. Katseta mitmesuguste Risttahuka eksemplaridega.
* Koosta mitmesuguste  Kujundite  massiiv. Loo alamprogramm leidmaks massiivis olevate 
kujundite ruumalade summa. Loo eraldi alamprogramm leidmaks massiivis olevate kujundite 
pindalade  summa.
Meetodite asendus
Harilikult kirjutatakse meetodite üle katmise juures ülemklassi meetodi ette virtual ning alamklassi 
juurde override. Sellisel juhul alamklassi (siinses näites Daami) objekti puhul kasutatakse alati seda 
meetodit, mis tema juurde käib - sõltumata, millisest tüübist on muutuja, mille kaudu eksemplari 
poole pöördutakse. C++ võimalusi säilitades aga on jäetud ka teine võimalus. Meetodi võib 
asendada nõnda, et tema kirjeldamise ette kirjutatakse sõna new. Sel juhul peidetakse vana meetod 
samuti ära. Vana meetodi saab aga kätte juhul, kui objekti poole pöörduda ülemklassi muutujast, 
kus vastav meetod vanal kujul kasutusel oli. Kui virtual/override puhul pidid  parameetrid  ja 
väljastustüüp samaks jääma, siis new loob täiesti uue ja eelmisest sõltumatu meetodi. 
Järgnevas näites on ehitatud kunstlik pärilusahel. Ülemklassiks Inimene, kes ütleb oma vanuse 
nõnda nagu see on. Inimesest pärinenud Daam võtab ilma pikemalt mõtlemata 5 aastat maha. 
Daami alamklassiks olev  Beib  keeldub üldse vanuse teatamisest ning eriti kaugele arenenud 
KavalBeib palub kasutajal ise tema vanust pakkuda. Sõna sealed klassi juures näitab, et sellest 
klassist ei lubata enam edasi pärida. Selline määrang aitab kompilaatoril koodi optimeerida. 
Alljärgnevalt katsetatakse, millist tüüpi muutuja kaudu millise tegeliku objekti poole pöördumisel 
milline tulemus saadakse. Et omistamine on võimalik ainult ülemklassi suunas, siis igaühe neist 
saab omistada Inimese tüüpi muutujale. Mida tase edasi, seda vähem on omistusvõimalusi. 
Katsetamise käigus antakse Beiblastele vanuseks 17 aastat, teistele 40. Ning jälgitakse, milline 
meetod millise muutuja kaudu väljakutsel käima läheb. Kõige pikem ja keerukam lugu on Kavala 
Beibega. Et ta on pärimispuus kõige kaugemal, siis teda on võimalik omistada kõikide selles puus 
olevate tüüpidega muutujatele. Enese tüübi puhul küsib ta vanuseks 19, nagu käskluses öeldud. Ka 
lihtsalt Beib-tüüpi muutuja kaudu küsib ta enesele 19, sest klassi Beib meetod YtleVanus on virtual 
ning tegelikult käima läheb objekti enese ehk klassis KavalBeib loodud meetod. 
Edasi muutub lugu keerulisemaks. Daami-muutujast välja kutsutav Kavala  Beibe  vanus tuleb 12, 
sest ta lahutab aastad maha nagu Daamile  kohane. Ning ka hariliku inimese kaudu tuleb 12, sest 
virtual-piiritleja kaudu võetakse käsklus võimalikult objekti enese lähedalt.
using System;
namespace Asendus{
 class Inimene{
   protected int vanus;
   public Inimene(int uvanus){
      vanus=uvanus;
   }
   public virtual void YtleVanus(){
      Console.WriteLine("Minu vanus on "+vanus+" aastat");
   }
 }
 class Daam:Inimene {
   public Daam(int vanus):base(vanus){}
   public override void YtleVanus(){
      Console.WriteLine("Minu vanus on "+(vanus-5)+" aastat");   
   }
 }
 class Beib:Daam{
   public Beib(int vanus):base(vanus){}
   new public virtual void YtleVanus(){
       Console.WriteLine("Minu vanus pole sinu asi, vot!");
   }
 }
 sealed class KavalBeib:Beib{ //siit ei saa enam edasi areneda
   public KavalBeib(int vanus):base(vanus){}
   public override void YtleVanus(){
      Console.WriteLine(" Arva , kas olen {0}?", vanus+2);
   }
 }
 class InimTest{
  public static void Main(string[] arg){
     KavalBeib kb=new KavalBeib(17);
     Beib b=new Beib(17), bkb=kb;
     Daam d=new Daam(40), db=b, dkb=kb;
     Inimene i=new Inimene(40), id=d, ib=b,ikb=kb;
     kb.YtleVanus();
     b.YtleVanus();
     bkb.YtleVanus();
     d.YtleVanus();
     db.YtleVanus();
     dkb.YtleVanus();
     i.YtleVanus();
     id.YtleVanus();
     ib.YtleVanus();
     ikb.YtleVanus();
  }
 }
}
/*
D:\kodu\0606\opikc#>Asendus
Arva, kas olen 19?
Minu vanus pole sinu asi, vot!
Arva, kas olen 19?
Minu vanus on 35 aastat
Minu vanus on 12 aastat
Minu vanus on 12 aastat
Minu vanus on 40 aastat
Minu vanus on 35 aastat
Minu vanus on 12 aastat
Minu vanus on 12 aastat
*/
Ülesandeid
* Loo klass Punkt väljadega x ja y ning meetoditega KaugusNullist ja TeataAndmed. Esimene 
väljastab reaalarvuna kauguse koordinaatide  alguspunktist . Teine  tagastab  tekstina koordinaatide 
väärtused.
* Loo Punktile alamklass RuumiPunkt. Lisa väli z, kata üle KaugusNullist ning asenda 
TeataAndmed. Esimene väljastab kauguse nullist kolme koordinaadi korral, teine aga kirjutab 
RuumiPunkti andmed ekraanile, meetodid tagastustüübiks on void. 
* Katseta loodud objekte ja nende käsklusi igal võimalikul moel. Punkt Punkti muutujast, 
RuumiPunkt RuumiPunkti muutujast ning RuumiPunkt Punkti muutujast.
Omadused
Objektide juures tehakse enamasti selget vahet: väljad ehk muutujad on andmete hoidmiseks, käsud 
ehk funktsioonid ehk meetodid toimingute sooritamiseks, muuhulgas  ka andmete poole 
pöördumiseks. Ning korralikult kapseldatud objektorienteeritud programmis pääseb väljadele otse 
ligi vaid objekti seest, kõik muud välised toimetused käivad meetodite kaudu. 
Kahjuks või õnneks on enamik programmeerijaid kirjutanud ka objektikaugemat koodi. Kes 
sellepärast, et tema kooliajal polnud veel objektorienteeritus kuigi laialt levinud või mõni teine 
põhjusel, et piisavalt väikeste programmide puhul võib olla objektindusest rohkem tüli kui tulu. 
Nõnda pakuvad programmeerimiskeeled mitmesuguseid "vahevorme", kus püütakse kasu lõigata 
objektide süstemaatilisusest ning samal ajal jätta alles protseduuridel põhineva programmeerimise 
lihtsuse. 
Eelpool  oli selliseks heaks mooduseks kirje (struct). Kirje puhul eeldatakse, et ta on loodud 
põhiliselt andmete hoidmiseks, andmete õigsuse ja kokkusobivuse eest hoolitseb väline programm, 
et tegemist on lihtsalt muutujate komplektiga nagu näiteks punkti koordinaadid. Kirje vaid 
hoolitseb, et x ja y alati kokku kuuluksid. 
Siiski on erinevalt mõnest muust keelest C# puhul lubatud kirje juurde ka käsklusi lisada. Enamasti 
kasutatakse neid arvutatavate omaduste - nagu näiteks sünniaja järgi vanuse - leidmiseks. Kirje 
kasutamise teeb objektist mugavamaks käskude mõningane lühidus. Seal võib rahulikult kirjutada
p1.X=17;
int a=p1.X;
Objektide puhul peetakse sellist otse muutujate poole pöördumist ebaviisakaks. Paremaks 
lahenduseks soovitatakse
p1.paneX(17);
int a=p1.KysiX();
On küll vaid paar tähte juures, aga piisavalt selle jaoks, et laisad programmeerijad vahel pigem 
muudavad objekti muutujad otse ja avalikult kättesaadavaks, kui et andmeid viisakalt meetodite 
kaudu vahetavad. Et lühidat kirjastiili säilitada ning samas jätta alles meetoditele iseloomulik 
kontrollitavus ja muudetavus, selleks ongi loodud võimalus objektile luua omadusi, mis näevad 
välja nagu muutujad, kuid käituvad nagu meetodid.
Järgnevas näites on klassi Ilmaandmed eksemplaridele lisatud omadus Temperatuur, millele saab 
väljapoolt väärtust omistada ning küsida nagu tavaliselt muutujalt ehk väljalt. Küsimise peale 
pannakse lihtsalt tööle get-koodiosa ning omistamise  peale set-koodiosa. Sõna "
80% sisust ei kuvatud. Kogu dokumendi sisu näed kui laed faili alla
Vasakule Paremale
Nimetu #1 Nimetu #2 Nimetu #3 Nimetu #4 Nimetu #5 Nimetu #6 Nimetu #7 Nimetu #8 Nimetu #9 Nimetu #10 Nimetu #11 Nimetu #12 Nimetu #13 Nimetu #14 Nimetu #15 Nimetu #16 Nimetu #17 Nimetu #18 Nimetu #19 Nimetu #20 Nimetu #21 Nimetu #22 Nimetu #23 Nimetu #24 Nimetu #25 Nimetu #26 Nimetu #27 Nimetu #28 Nimetu #29 Nimetu #30 Nimetu #31 Nimetu #32 Nimetu #33 Nimetu #34 Nimetu #35 Nimetu #36 Nimetu #37 Nimetu #38 Nimetu #39 Nimetu #40 Nimetu #41 Nimetu #42 Nimetu #43 Nimetu #44 Nimetu #45 Nimetu #46 Nimetu #47 Nimetu #48 Nimetu #49 Nimetu #50 Nimetu #51 Nimetu #52 Nimetu #53 Nimetu #54 Nimetu #55 Nimetu #56 Nimetu #57 Nimetu #58 Nimetu #59 Nimetu #60 Nimetu #61 Nimetu #62 Nimetu #63 Nimetu #64 Nimetu #65 Nimetu #66 Nimetu #67 Nimetu #68 Nimetu #69 Nimetu #70 Nimetu #71 Nimetu #72 Nimetu #73 Nimetu #74 Nimetu #75 Nimetu #76 Nimetu #77 Nimetu #78 Nimetu #79 Nimetu #80 Nimetu #81 Nimetu #82 Nimetu #83 Nimetu #84 Nimetu #85 Nimetu #86 Nimetu #87 Nimetu #88 Nimetu #89 Nimetu #90 Nimetu #91 Nimetu #92 Nimetu #93 Nimetu #94 Nimetu #95 Nimetu #96 Nimetu #97 Nimetu #98 Nimetu #99 Nimetu #100 Nimetu #101 Nimetu #102 Nimetu #103 Nimetu #104 Nimetu #105 Nimetu #106 Nimetu #107 Nimetu #108 Nimetu #109 Nimetu #110 Nimetu #111 Nimetu #112 Nimetu #113 Nimetu #114 Nimetu #115 Nimetu #116 Nimetu #117 Nimetu #118 Nimetu #119 Nimetu #120 Nimetu #121 Nimetu #122 Nimetu #123 Nimetu #124 Nimetu #125 Nimetu #126 Nimetu #127 Nimetu #128 Nimetu #129 Nimetu #130 Nimetu #131 Nimetu #132 Nimetu #133 Nimetu #134 Nimetu #135 Nimetu #136 Nimetu #137 Nimetu #138 Nimetu #139 Nimetu #140 Nimetu #141 Nimetu #142 Nimetu #143 Nimetu #144 Nimetu #145 Nimetu #146 Nimetu #147 Nimetu #148 Nimetu #149 Nimetu #150 Nimetu #151 Nimetu #152 Nimetu #153 Nimetu #154 Nimetu #155 Nimetu #156 Nimetu #157 Nimetu #158 Nimetu #159 Nimetu #160 Nimetu #161 Nimetu #162 Nimetu #163 Nimetu #164 Nimetu #165 Nimetu #166 Nimetu #167 Nimetu #168 Nimetu #169 Nimetu #170 Nimetu #171 Nimetu #172 Nimetu #173 Nimetu #174 Nimetu #175 Nimetu #176 Nimetu #177 Nimetu #178 Nimetu #179 Nimetu #180 Nimetu #181 Nimetu #182 Nimetu #183 Nimetu #184 Nimetu #185 Nimetu #186 Nimetu #187 Nimetu #188 Nimetu #189 Nimetu #190 Nimetu #191 Nimetu #192 Nimetu #193 Nimetu #194 Nimetu #195 Nimetu #196 Nimetu #197 Nimetu #198 Nimetu #199 Nimetu #200 Nimetu #201 Nimetu #202 Nimetu #203 Nimetu #204 Nimetu #205 Nimetu #206 Nimetu #207 Nimetu #208 Nimetu #209 Nimetu #210 Nimetu #211 Nimetu #212 Nimetu #213 Nimetu #214 Nimetu #215 Nimetu #216 Nimetu #217 Nimetu #218 Nimetu #219 Nimetu #220 Nimetu #221 Nimetu #222 Nimetu #223 Nimetu #224 Nimetu #225 Nimetu #226 Nimetu #227 Nimetu #228 Nimetu #229 Nimetu #230 Nimetu #231 Nimetu #232 Nimetu #233 Nimetu #234 Nimetu #235 Nimetu #236 Nimetu #237 Nimetu #238 Nimetu #239 Nimetu #240 Nimetu #241 Nimetu #242 Nimetu #243 Nimetu #244 Nimetu #245 Nimetu #246 Nimetu #247 Nimetu #248 Nimetu #249 Nimetu #250 Nimetu #251 Nimetu #252 Nimetu #253 Nimetu #254 Nimetu #255 Nimetu #256 Nimetu #257 Nimetu #258 Nimetu #259 Nimetu #260 Nimetu #261 Nimetu #262 Nimetu #263 Nimetu #264 Nimetu #265 Nimetu #266 Nimetu #267 Nimetu #268 Nimetu #269 Nimetu #270 Nimetu #271 Nimetu #272 Nimetu #273 Nimetu #274 Nimetu #275 Nimetu #276 Nimetu #277 Nimetu #278 Nimetu #279 Nimetu #280 Nimetu #281 Nimetu #282 Nimetu #283 Nimetu #284 Nimetu #285 Nimetu #286 Nimetu #287 Nimetu #288 Nimetu #289 Nimetu #290 Nimetu #291 Nimetu #292 Nimetu #293 Nimetu #294 Nimetu #295 Nimetu #296 Nimetu #297 Nimetu #298 Nimetu #299 Nimetu #300 Nimetu #301 Nimetu #302 Nimetu #303 Nimetu #304 Nimetu #305 Nimetu #306 Nimetu #307 Nimetu #308 Nimetu #309 Nimetu #310 Nimetu #311 Nimetu #312 Nimetu #313 Nimetu #314 Nimetu #315 Nimetu #316 Nimetu #317 Nimetu #318 Nimetu #319 Nimetu #320 Nimetu #321 Nimetu #322 Nimetu #323 Nimetu #324 Nimetu #325 Nimetu #326 Nimetu #327 Nimetu #328 Nimetu #329 Nimetu #330 Nimetu #331 Nimetu #332 Nimetu #333 Nimetu #334 Nimetu #335 Nimetu #336 Nimetu #337 Nimetu #338 Nimetu #339 Nimetu #340 Nimetu #341 Nimetu #342 Nimetu #343 Nimetu #344 Nimetu #345 Nimetu #346 Nimetu #347 Nimetu #348 Nimetu #349 Nimetu #350 Nimetu #351 Nimetu #352 Nimetu #353 Nimetu #354 Nimetu #355 Nimetu #356 Nimetu #357 Nimetu #358 Nimetu #359 Nimetu #360 Nimetu #361 Nimetu #362 Nimetu #363 Nimetu #364 Nimetu #365 Nimetu #366 Nimetu #367 Nimetu #368 Nimetu #369 Nimetu #370 Nimetu #371 Nimetu #372 Nimetu #373 Nimetu #374 Nimetu #375 Nimetu #376 Nimetu #377 Nimetu #378 Nimetu #379 Nimetu #380 Nimetu #381 Nimetu #382 Nimetu #383 Nimetu #384 Nimetu #385 Nimetu #386 Nimetu #387 Nimetu #388 Nimetu #389 Nimetu #390 Nimetu #391 Nimetu #392 Nimetu #393 Nimetu #394 Nimetu #395 Nimetu #396 Nimetu #397 Nimetu #398 Nimetu #399 Nimetu #400 Nimetu #401 Nimetu #402 Nimetu #403 Nimetu #404 Nimetu #405 Nimetu #406 Nimetu #407 Nimetu #408 Nimetu #409 Nimetu #410 Nimetu #411 Nimetu #412 Nimetu #413 Nimetu #414 Nimetu #415 Nimetu #416 Nimetu #417 Nimetu #418 Nimetu #419 Nimetu #420 Nimetu #421 Nimetu #422 Nimetu #423 Nimetu #424 Nimetu #425 Nimetu #426 Nimetu #427 Nimetu #428 Nimetu #429 Nimetu #430 Nimetu #431 Nimetu #432 Nimetu #433 Nimetu #434 Nimetu #435 Nimetu #436 Nimetu #437 Nimetu #438 Nimetu #439 Nimetu #440 Nimetu #441 Nimetu #442 Nimetu #443 Nimetu #444 Nimetu #445 Nimetu #446 Nimetu #447 Nimetu #448 Nimetu #449 Nimetu #450 Nimetu #451 Nimetu #452 Nimetu #453 Nimetu #454 Nimetu #455 Nimetu #456 Nimetu #457 Nimetu #458 Nimetu #459 Nimetu #460 Nimetu #461 Nimetu #462 Nimetu #463 Nimetu #464 Nimetu #465 Nimetu #466 Nimetu #467 Nimetu #468 Nimetu #469 Nimetu #470 Nimetu #471 Nimetu #472 Nimetu #473 Nimetu #474 Nimetu #475 Nimetu #476 Nimetu #477 Nimetu #478 Nimetu #479 Nimetu #480 Nimetu #481 Nimetu #482 Nimetu #483 Nimetu #484 Nimetu #485 Nimetu #486 Nimetu #487 Nimetu #488 Nimetu #489 Nimetu #490 Nimetu #491 Nimetu #492 Nimetu #493 Nimetu #494 Nimetu #495 Nimetu #496 Nimetu #497 Nimetu #498 Nimetu #499 Nimetu #500 Nimetu #501 Nimetu #502 Nimetu #503 Nimetu #504 Nimetu #505 Nimetu #506 Nimetu #507 Nimetu #508 Nimetu #509 Nimetu #510 Nimetu #511 Nimetu #512 Nimetu #513 Nimetu #514 Nimetu #515 Nimetu #516 Nimetu #517 Nimetu #518 Nimetu #519 Nimetu #520 Nimetu #521 Nimetu #522 Nimetu #523 Nimetu #524 Nimetu #525 Nimetu #526 Nimetu #527 Nimetu #528 Nimetu #529 Nimetu #530 Nimetu #531 Nimetu #532 Nimetu #533 Nimetu #534 Nimetu #535 Nimetu #536 Nimetu #537 Nimetu #538 Nimetu #539 Nimetu #540 Nimetu #541 Nimetu #542 Nimetu #543 Nimetu #544 Nimetu #545 Nimetu #546 Nimetu #547 Nimetu #548 Nimetu #549 Nimetu #550 Nimetu #551 Nimetu #552 Nimetu #553 Nimetu #554 Nimetu #555 Nimetu #556 Nimetu #557 Nimetu #558 Nimetu #559 Nimetu #560 Nimetu #561 Nimetu #562 Nimetu #563 Nimetu #564 Nimetu #565 Nimetu #566 Nimetu #567 Nimetu #568 Nimetu #569 Nimetu #570 Nimetu #571 Nimetu #572 Nimetu #573 Nimetu #574 Nimetu #575
Punktid 5 punkti Autor soovib selle materjali allalaadimise eest saada 5 punkti.
Leheküljed ~ 575 lehte Lehekülgede arv dokumendis
Aeg2013-08-08 Kuupäev, millal dokument üles laeti
Allalaadimisi 16 laadimist Kokku alla laetud
Kommentaarid 1 arvamus Teiste kasutajate poolt lisatud kommentaarid
Autor Õppematerjali autor

Meedia

Mõisted

omandamiseks, käesolev juhend, siinses materjalis, päris algajatele, värvilisem, võrreldes veebimaailmaga, kohta midagigi, microsofti, olukordi, platvormi nimeks, hea uudis, raamistiku puhul, binaarset koodi, net raamistik, serverid, visual studio, express versioone, programmeerimiskeeltena, microsoft, wpf, wcf, windows cardspace, ridade pikkuseks, korduvaid klassinimesid, lihtsam moodus, töötavaid graafikakomponente, märksõnaks, nagu tingimusest, massiivielemendi puhul, string, levinumatest, käsurea, normaal, muutmisvõimalus, väärtuste küsimiseks, tüüpiliselt, xml, tavalisimaks elemendiks, ajapikku, tavanäiteks, niisamuti, alati väärtuse, lihtsalt beib, virtual, paisktabelile, võtmeks, takistuseks, takistuse põhjal, kogutakistus, voolu läbilaskmisel, salv, kellaaega, enamikel juhtudel, käsu ülesandeks, ühissõiduk, tagastatakse järjekorranumbrina, nime taga, alamprogrammile trüki, viimatine aastaarv, vajutati, debug, edasi cd, sql, sql, sql server, enterprise edition, standard edition, web edition, workgroup edition, express edition, compact edition, express versioonile, vaikimisi, publik, dbcreator, kasutajakontod, turvakaalutlustel, lisaks sellele, sql server, visual studio, database engine, reporting services, integration services, windows authentication, vaikimisi, teatud tegevusi, väikestel andmebaasidel, pärast refresh, graafiline liides, skriptist, programmeerija elu, rohkem kasutatavad, tavalisim int, 10 kohta, date, hierarchyid, identifitseerimistulba linnid, laused, väli vanus, nagu näeme, paindlikkus, nagu näeme, sisestamata, osavalt seadistatud, andmete muutmiseks, lemmikloomal, looma nimi, peremees, seoseid, valikuid tegevusteks, cascade, set null, set default, lemmiklooma juures, ridadest, join lapsed, sql 2005, süntaks, grupeerimise juures, esimese linna, tabelikoopiate id, väljatrükk, lisatud näited, üheks võimaluseks, abs, sest salapärane, kolmanda tulba, tõepoolest, andmetüüpide loomiseks, piiranguid, ühele väljale, konstraantide rakendamine, konstraante, esmajärjekorras, võimalus selleks, ajutised tabelid, ajutised tabelid, transact, schema loomiseks, vaikimisi, igale kasutajale, lisaks sellele, grant alter, grant select, cte abil, pivot, lahenduseks, kasuta sql, apply, tulbas, transaktsioonid, automaatsed transaktsioonid, hariliku update, genereerimise juures, openxml, rowpattern, idoc, schemadeclaration, tablename, sql, binaarandmete asemel, andmehoidla, infoühikud, tabelid, net, andmeallikad, kontrollimiseks, andmeallikaga, ühendusteksti luues, data source, initial catalog, integrated security, presist security, ühenduste sulgemine, staatuse kontrollimiseks, connection, commandtype, commandtext, parameters, parameetrite kasutamiseks, datareader, datareaderi tekitamiseks, viimase võimalusena, mingil väljal, ühenduseta keskkonnas, jooksutavatel arvutitel, andmete lisamiseks, ridasid, dataset, dataadapter klass, raamistikuga, oledbdataadapter, sqldataadapter, language, dataadapteri küljes, selectcommand, insertcommand, updatecommand, deletecommand, fill meetod, update meetod, dataadapter, muutunud kirjeid, getchanges meetodist, xml, xml, xml, atribuute, 1 tühiruum, xhtml, täiendavalt, allolevas näites, neid reegleid, xml skeemid, reeglitega, lisaks sellele, koosta xml, tag, parent, xml, xml, lugemise ajal, parsimine, xml failil, valid, xmli, net, veebivormidele, netist, palju koodi, usaldavale inimesele, tekstiredaktoriga kirjutamisel, visual studio, lisaks kommertsversioonidele, lisaks sellele, saadetav tekst, mitmesugused tehnoloogiad, kujundada html, wordi dokumentidel, 0 transitional, tekita html, hädavajalik, tähekombinatsiooniga http, edasi pordi, refresh, küsida alternatiivteksti, sobivasse alt, definitsiooniloend, definition term, disainivaates, mõlemat pidi, viite loomiseks, lehestiku kujundamisel, liiatigi, laadi, viimatises näites, solution explorer, klassi rahvas, programmeeritaval veebilehel, sisestus, onclick, millise tehte, rippmenüüs, neti juures, andmetüüp int, veebilehe tarvis, nimealgusega cs, edasi html, ühendusteksti, sql, datakeynames, delete, mitmelgi moel, select, nagu insert, lisamislõik, kommentaarid, avanevas aknas, ainukese tekstivälja, pärast add, select, avalik ligipääs, iseenese eest, lehe loomisel, anonüümsele kasutajale, sisselogitule, käitumiseks, edasi logout, lihtsam moodus, sqldatasource, hoidmis, üheks arengusuunaks, microsoftil, tabelitepõhises andmebaasisüsteemis, viimased, tabeli puhul, kõigepealt select, veebis, nagu ikka, kassi id, veidi raskem, visual studio, andmetabeli juures, bind, vaikimisi väärtuseks, net veebirakendused, file system, ftp site, remote site, 2 iis, 3 ftp, 4 eneta, 5 http, 6 https, 7 sharepoint, codefile atribuut, inherits atribuut, olevat teksti, config failid, netil, warn, trace elemendil, jälitusinfo, mugavat alternatiivi, globaalne veakontroll, vea uurimiseks, kõigil lehtedel, ajax, neti, ajax, samal leheküljel, resx fail, atribuudid, ressursside lugemiseks, globaalseteks, teenusepakkuja, keele muudatus, lehekülje loomisel, serveri elementidel, label, konteinereid, literal, muus osas, placeholder, textbox, võlur, võlureid, võlur, validation kontrollid, enamgi veel, kõigil validaatoritel, display, controltovalidate, errormessage, setfocusonerror, validationgrupp, sitemap, menüü sisu, kk lehed, page element, cs seest, font, font, font, erinevuseks, peakujundus, spetsiaalkujundus, viewstate klassi, viewstate klassil, authentication, authorization, lisaks sellele, hea uudis, net keskkonnas, suhtlusreeglid, ühenduse loomiseks, turvalisuse saavutamiseks, toodedatacontext, lisaks sellele, lihtsateks loeteludeks, adrotator, listbox, radiobuttonlist, checkboxlist, keerukateks loeteludeks, gridview, detailsview, formview, repeater, hierarhilised loetelud, treeview, menu, isikupärastamine, isikupärastada, tehtud muudatused, veebiteenus, veebiteenused, veebiteenuste faililaiendiks, programmeerimine, wcf, wsdl fail, iis teenus

Sisukord

  • Sisukord
  • Eessõna
  • Sissejuhatus
  • Õppematerjali kasutamise juhis
  • Kuidas saada abi küsimustele
  • Microsoft .NET platvorm
  • Põhivõimalused
  • Kui rakendus juba mingitki elumärki annab, on see tunduvalt rohkem, kui lihtsalt hulk
  • Nii nagu talumees, kes omale krati oli ehitanud, sai hakata talle ülesandeid andma alles siis
  • Ning C# puhul näeb lühim tervikprogramm välja ligikaudu järgmine
  • Käivitamine
  • Ülesandeid
  • Suhtlus arvutiga
  • Arvutamine
  • Valikud
  • Kommentaarid
  • Kordused
  • Järelkontroll
  • Korrutustabel
  • Alamprogramm
  • Massiivid
  • Tsükkel andmete kasutamiseks
  • Massiiv ja alamprogramm
  • Algväärtustamine, järjestamine
  • Osutid ja koopiad
  • Massiiv alamprogrammi parameetrina
  • Mitmemõõtmeline massiiv
  • Käsud mitmes failis
  • Tekst
  • Muutmine
  • Tükeldamine
  • Tekstifailid
  • Kirjutamine
  • Lisamine
  • Lugemine
  • Juhuarv
  • Omaloodud andmestruktuur
  • Punktimassiiv
  • Edasijõudnute osa: Objektorienteeritud programmeerimine
  • Tutvustus
  • Klassimuutuja
  • Osuti, omistamine
  • Dokumenteerivad kommentaarid
  • Readonly
  • Näide
  • Kompileerimine
  • Kommentaarifail
  • Pärilus
  • Päriluseta näide
  • Alamklass
  • Ülekate
  • Liidesed
  • Abstraktne klass
  • Meetodite asendus
  • Omadused
  • Pöördumisstatistika
  • Indekseering
  • Vahendus
  • Struktuurne andmestik
  • Ühine ülemklass
  • Operaatorite üledefineerimine
  • Kui kõik saadud kiidusõnad kokku liita, siis võib end küll inglina tunda
  • Tüübimuundusoperaatorid
  • Võrdlusoperaatorid
  • Abivahendid
  • Erindid
  • Püüdmine
  • Reageering tüübi põhjal
  • Püüdmine alamprogrammist
  • Erindi heitmine
  • Andmekollektsioonid
  • ArrayList
  • Sortimine
  • Tüübimäärang
  • Järjekord
  • Paisktabel
  • Mallid
  • Atribuudid
  • Omaloodud atribuut
  • Atribuutide parameetrid
  • Andmebaasiliides
  • Ühenduse loomine, päring
  • Andmete lisamine
  • SQL-parameeter
  • Salvestatud protseduur
  • Funktsiooni delegaadid
  • Funktsioonide komplekt
  • Sündmused
  • Ilmajaamad
  • Graafiline liides
  • Visual Studio C# Expressi install
  • Esimese rakenduse loomine
  • Kokkuvõte
  • SQLi keel
  • Microsoft SQL Server 2008
  • SQL Server 2008
  • SQL Server Express Edition
  • Ettevalmistused installeerimiseks
  • Installeerimine
  • Seadistamine
  • Töö alustamine
  • Andmebaasi loomine
  • Tabeli loomine
  • Andmetüübid
  • Primaarvõti
  • Andmete sisestus
  • Harjutus (tabeli loomine)
  • Lihtsamad päringud
  • Agregaatfunktsioonid
  • Kustutamine
  • Harjutus (lihtsad päringud)
  • Harjutuste vastused (lihtsad päringud)
  • Tabelite vahelised seosed
  • Tabelite ühendamine päringutes
  • Edasijõudnutele
  • Pikemad päringud
  • Tingimuste kombineerimine
  • TOP, päringu algusosa
  • Grupeerimine
  • ROLLUP, gruppide koondinfo
  • CUBE, täiendatud koondinfo
  • Harjutused (pikemad päringud)
  • Keerukamad seosed tabelite vahel
  • CROSS JOIN
  • Seos sama tabeliga
  • Päringutulemuste ühendamine
  • Harjutused (tabelite ühendamine)
  • Alampäringud
  • Tabeli asendaja
  • Väärtuse asendaja
  • Sarnase pikkusega lapsed
  • Veeru asendaja
  • Tekkinud tabelite ühendamine
  • Harjutused (Alampäringud)
  • Lisavõimalused
  • Andmetüüpide loomine
  • Andmete ühtsuse tagamine
  • Loomine
  • Käivitus
  • Ajutiste tabelite kasutamine
  • Tsükkel, valik
  • Muutujasse lugemine
  • Schema
  • Common Table Expression
  • PIVOT JA UNPIVOT
  • APPLY
  • Nummerdamised
  • Vaade
  • Transaktsioonid (Transaction)
  • XML andmete kasutamine
  • FOR XML
  • OPENXML
  • Varukoopia
  • Taastamine
  • Andmetele ligipääs ADO.NET
  • Andmeallika külge ühendumine
  • Töötamine andmebaasiga ühendatud keskkonnas
  • XxxCommand
  • Parameetrite kasutamine
  • Ridade lugemine väljundist (DataReader)
  • Transaktsioonid
  • Töötamine ühenduseta keskkonnas (DataSets)
  • Olemasolevate andmete põhjal DataSeti loomine
  • XML’i kirjutamise reeglid
  • Reeglid
  • XML’i elemendid
  • XHTML
  • Nimeruum
  • XML’i valideerimine
  • XML skeemid
  • XMLi kasutamine SqlServeris
  • XMLi genereerimine relatsioonilistest andmetest
  • XML andmetüübi kasutamine
  • XML andmete kasutamine .NET raamistikus
  • XMLi parsimine
  • XMLi valideerimine
  • XMLi salvestamine
  • LINQ - .NET Language-Integrated Query
  • ASP.NET
  • Visual Studio paigaldamine
  • Lihtsa veebilehestiku loomine HTML keele abil
  • Esimene veebileht
  • Esimene veebileht Visual Studio abil
  • Piltide kasutamine veebilehel
  • Seotud lehed
  • Astmelised laadilehed (CSS)
  • Näite kopeerimine
  • Pildi suuruse muutmine
  • Käskluste valik
  • Valmisnäidete kasutamine
  • Määramine päises
  • Laadileht eraldi failis
  • Kujundusklass
  • Programmeeritavad veebilehed
  • Kellaaeg
  • Arvutav veebileht
  • Tehtevalikuga kalkulaator
  • Andmebaasipõhise veebirakenduse loomine
  • Andmetabeli näitamine veebilehel
  • Lähtekood
  • Andmete muutmine ja lisamine veebilehelt
  • Otsing
  • Lehe kaitsmine parooliga
  • Andmed mitmes tabelis
  • Tabelite loomine ja sidumine
  • Andmete vaatamine
  • Ülesanne
  • Andmete muutmine
  • Veebi kopeerimine
  • Programmi koodi paigutamine eraldi faili
  • Seadistamine (Web.config)
  • Rakenduse jälgimine
  • Vigade haldamine
  • Rakenduse veebist eemaldamine
  • Globaalne veakontroll
  • Keskne veakontroll
  • Veakontroll lehel
  • Veakontroll koodis
  • AJAXi kasutamine
  • AJAX Control Toolkit
  • Lokaliseerimine
  • Lokaalsed ressursid
  • Globaalsed ressursid
  • Programselt keele muutmine
  • Master
  • Pages
  • Elemendid lehel
  • Standardsed serveri elemendid
  • Programselt hallatavad HTML elemendid
  • Sisendi kontrollimise elemendid (Validators)
  • Navigeerimiselemendid
  • Omaloodud elemendid (UserControl)
  • Veebilehtede kujundamine kasutades nägusid
  • Themes
  • Väärtuste tööaegne meelespidamine
  • Veebi globaalsed muutujad (Application variables)
  • Andmete puhverdamine (Cache variable)
  • Veebilehtede puhverdamine (OutputCache atribute)
  • Seansi muutujad (Session variables)
  • Lehelkülje seisund (ViewState variables)
  • Veebisaidi turvamine
  • Üldised seadistused
  • Kasutajate haldus
  • Rollide kasutamine ligipääsu kontrollimisel
  • Andmetega manipuleerimine
  • Andmete kasutamine ADO.NET abil
  • Andmete kasutamine LINQ abil
  • Andmete kuvamine lihtsate loetelude abil
  • Andmete kuvamine keerukate loetelude abil
  • Hierarhiliste andmete kuvamine
  • WebParts
  • Veebiteenused
  • Veebiteenuste tegemine
  • WCF teenuste tegemine
  • Veebiteenuse kasutamine
  • Lisad
  • Ressursside hoidmine SQL Serveris – Resource Provider
  • Kasutajatunnuste hoidmine andmebaasis - MembershipProvider
  • Kasutajagruppide hoidmine andmebaasis – RoleProvider
  • C# põhikonstruktsioonid

Kommentaarid (1)

mantonio profiilipilt
mantonio: Tundub, et see ei ole C. See on C#.
19:51 01-03-2016


Sarnased materjalid

184
docx
Andmebaasipõhiste veebirakenduste arendamine Microsoft Visual Studio ja SQL Server’i baasil
85
doc
C-materjal
816
pdf
Matemaatika - Õhtuõpik
91
doc
Exeli õpetus
1072
pdf
Logistika õpik
238
docx
PHP ALUSED RAAMAT
937
pdf
Erakorralise meditsiini tehniku käsiraamat
89
doc
Loogika ja programmeerimine





Faili allalaadimiseks, pead sisse logima
Kasutajanimi / Email
Parool

Unustasid parooli?

Pole kasutajat?

Tee tasuta konto

UUTELE LIITUJATELE KONTO MOBIILIGA AKTIVEERIMISEL +50 PUNKTI !