• Windows
• macOS ja Linux

Lisätietoa: Git-ohje: clone, reference: clone

Tiedostojen vieminen paikalliseen tietovarastoon (add, commit)

Kun tiedostoja lisätään, muokataan tai poistetaan, tulee kaikki nämä muutokset lisätä paikalliseen tietovarastoon.

Tämä vaihe tehdään joka kerta kun olet tehnyt muutoksia koodiin tai muihin tiedostoihin.

Esimerkki: Suunnitelman kuvan tallentaminen. Tallenna harjoitustyösi suunnitelman sekä luonnoskuvan suunnitelma-kansioon. Ole tarkkana, että kuva menee oikeasti juuri tuohon kansioon. Sekä suunnitelmatekstiä varten että kuvaa varten on olemassa esimerkit suunnitelma-kansiossa.

Kuvan pikselikoon tulee olla enintään 1920 x 1080 pikseliä. Kuvan tiedostokoon tulee olla enintään 1 megtavu.

Avaa Pääte (macOS), Git Bash (Windows) tai muu komentorivi, siirry cd-komentoja käyttämällä harkkatyökansioosi ja anna seuraavat kaksi komentoa:

git add --all 
git commit -m "kuvaava viesti miksi muutokset on tehty"

Ensimmäinen komento lisää kaikki muokatut tiedostot ns. index/stage-alueelle, ja seuraava komento tekee varsinaisen tietovarastoon tallentamisen.

On tärkeää, että aina add-komennon jälkeen tarkistat git status-komennolla mitä tiedostoja tietovarastoon on menossa. Älä lähetä tietovarastoihin suuria tiedostoja.

Mikäli et halua lähettää tietovarastoon kaikkia muutoksia, vaan esimerkiksi vain yhden tiedoston, laita --all-option tilalle haluamasi tiedoston nimi:

git add TIEDOSTONNIMI   (hakemistoineen, /-viiva hakemistomerkkinä)

Jotkut pitävät parempana luetella kukin lisättävä tiedosto erikseen edellä mainitulla komennolla. Kummassakin tavassa (all-vipu, tai kukin tiedosto erikseen) on puolensa.

Huomaa, että .gitignore-tiedosto sisältää tiedot sellaisista tiedostoista, joita ei lähtökohtaisesti viedä versiohallintaan. Jos kuitenkin ehdottomasti haluat lisätä tällaisen, esimerkiksi .jar-päätteisen tiedoston, niin silloin on käytettävä -f -optiota, jolla pakotetaan lisäys. Esimerkiksi:

git add -f kerho.jar

Toinen vaihtoehto on erikseen sallia vastava jar lisäämällä .gitignore-tiedostoon rivin .jar perään rivi:

!kerho.jar

Tehtyjen muutosten lähettäminen etävarastoon (push)

Tässä vaiheessa paikalliseen tietovarastoon lähetetyt muutokset lähetetään etävarastoon.

Tämä vaihe tehdään joka kerta kun olet tehnyt muutoksia koodiin tai muihin tiedostoihin. Älä unohda tehdä tätä työskentelyn päätteeksi. Muutoin tiedot jäävät vain paikalliseen tietovarastoon.

Avaa Pääte (macOS), Git Bash (Windows) tai muu komentorivi. Siirry harjoitustyökansioosi cd-komentoja käyttämällä ja anna sitten komento

git push

Ensimmäisellä kerralla sinulta kysytään käyttäjätunnusta ja salasanaa. Valitse kirjautumisikkunassa muodoksi Salasana (Password), ei Token.

Anna käyttäjätunnus lyhyessä muodossa käyttäjätunnus ilman @-merkkiä ja loppuosaa. Salasana on se, jota käytät JY-verkossa.

Mikäli annat salasanan väärin, joudut muokkaamaan kirjautumistietojasi, ks. kohta 12.

MacOS-käyttäjät huomatkaa, että salasana on KIRJOITETTAVA vaikka sen kohdalla näkyisi avaimen kuva. Kun salasanaa kirjoitetaan, ei näyttöön tule mitään. Lopuksi on painettava enter. Jos tässä tulee virhe, niin gitlab-salasana on poistettava avainnipusta.

Tarkista tämän jälkeen Gitlab-osoitteestasi, että sieltä löytyy lähettämäsi tiedostot (alkukurssista ne kuvat).

Muutosten hakeminen etävarastosta paikalliseen varastoon (pull)

Kun sinä tai joku muu on muuttanut tiedostoja ja vienyt muutoksia etävarastoon, niin muutokset tulee hakea omalle koneelle. Yhteistyöskentelyssä on syytä aina työskentelyä aloittaessa antaa pull-komento.

Siirry hakemistoon, johon olet kloonannut projektin (ks. clone) ja anna komento:

git pull

Tässä kohti voi tulla kysymys siitä, että miten käyttäjä haluaa pull-komennon jatkossa toimivan. Ohj1-kurssin osalta toimiva vaihtoehto on

git config pull.rebase false

Lue tästä lisää esimerkiksi StackOverflowsta.

Git ja ryhmätyöskentely

Kun työskennellään ryhmässä esimerkiksi jos teet harjoitustyön parityönä, tulee kiinnittää erityistä huomiota git:in käyttöön, jotta välttyy turhalta työltä. Kun useampi työstää samaa tiedostoa, tulee helposti tilanne, jossa on tehty eri muokkauksia samoille riveille. Tällöin git ei tiedä mitä tehdä ja konfliktit täytyy ratkaista käsin. Tälläistä tilannetta kutsutaan nimellä Merge conflict ja se ilmaantuu kun omia muutoksia yrittää puskea tai kun muutoksia koitetaan hakea omalle koneelle.

Alla on esitetty tärkeimmät tavat, joilla vältytään ongelmilta, kun työstetään samaa haaraa ryhmänä.

• Kommunikoikaa selkeästi mitä työstätte ja milloin.

• Aina ennen kuin aloittaa koodaamisen, haetaan muutokset etävarastosta --rebase lipulla, jonka ansiosta omat muutokset asetetaan paikalliseen varastoon vasta etävarastosta haettujen muutosten jälkeen.

  git pull --rebase
  

• Kun viette (push) muutoksia etävarastoon, ilmoittakaa siitä muulle ryhmälle.

public override void Begin()
{
    PhysicsObject nelio = new PhysicsObject(100, 100, Shape.Rectangle);
    Add(nelio);
}

public override void Begin()
{
    PhysicsObject pallo = new PhysicsObject(50, 50, Shape.Circle);
    Add(pallo);
}

Huomioitavaa

Tiedostojen koko

Versionhallintajärjestelmä ei sovi suurten tiedostojen tallennukseen. Älä lähetä versiohallintaan esimerkiksi suuria kuva-, musiikki- tai videotiedostoja. Myöskään bin, obj ja vastaavat kansiot (sis. käännetyt ohjelmat ja muut IDE:n tuottamat käännöksen oheistiedostot) eivät kuulu versiohallintaan. Täydennä tarvittaessa .gitignore-tiedostoa.

Älä laita salaisuuksia versiohallintaan

Älä lisää projektisi commiteihin mitään salaista, kuten salasanoja tai henkilötietoja. Vaikka poistaisit tiedon seuraavassa commitissa, se jää Gitin projekti-historiaan, ja on löydettävissä julkaisun jälkeen. Mikäli kuitenkin lähetit etävarastoon jotain, jonka haluat poistaa myöhemmin, se onnistuu esimerkiksi BFG Repo-Cleaner-työkalun avulla.

Tapoja käyttää Gitiä

Aluksi ehdottomasti suositeltavin tapa on käyttää Gitiä komentoriviltä. On olemassa kuitenkin myös graafisia ympäristöjä Gitin käyttämiseen. Myös IDEissä on nykyään varsin asialliset Git-asiakasohjelmistot (eli käyttöliittymä Git-komentojen käyttämistä varten), joskin jokainen on aina vähän omanlaisensa ja vaatii totuttelua. Kaikkia alla mainittuja työkaluja voit kuitenkin käyttää ristiin. Kannattaa kokeilla eri tapoja. Mikroluokista löytyy ainakin komentorivityökalut, Eclipse sekä TortoiseGit.

• SmartGit (Windows, Linux, macOS)
• Fork (Windows, macOS)
• TortoiseGit (Windows)
• GitHub Desktop (Windows, macOS)
• Gitiä voi käyttää myös Windows Subsystem for Linuxin läpi.

Git termejä

• repository, suom. säilytyspaikka, tietovarasto tai arkisesti "repo" = Paikka jossa versioitava tieto tallennetaan, voi olla paikallinen (local) tai etä (remote). Periaatteessa samasta projektista voi olla samasta projektista useita säilytyspaikkoja niin paikallisesti kuin etänä. local repository on käytännössä hakemistossa oleva .git-hakemisto. Repository koostuu loogisesti commiteista, jotka muodostavat kokoelman projektin eri vaiheista. Näin mihin tahansa commitoituun kohtaan voidaan viitata tai tarvittaessa myös palata.
• fork = projektista tehty "kopiohaara", joka elää omaa elämäänsä irrallaan alkuperäisestä projektista. Fork ei ole Gitin toiminto, mutta useat ulkoiset Git-palvelimet (kuten GitHub ja GitLab) tarjoavat tämän toiminnon.
• origin = lyhenne käytettävän etävaraston osoitteelle (remote repository). Jos etäsäilytyspaikkoja on useita, tulee näitäkin useita.
• project = jokin selkeä projekti, joka tähtää esimerkiksi jonkin yhden ohjelmatuotteen tekemiseen
• working directory (tai workspace) = työhakemisto, lokaali työhakemisto (kaikki tiedostot ja versiot löytyvät tämän alla olevasta .git -hakemistosta, jos ne on koneelle haettu (fetch))
• index = varastoon seuraavalla commitilla siirrettävien tiedostojen luettelo (versioitavien, staging area joissakin lähteissä, koska tiedosto laitetaan "näytille"). Käytännössä tiedosto .git/index.
• main = projektin päähaaran oletusnimi, joka pyritään pitämään toimivana koodina. Aikaisemmin päähaaran oletusnimi oli master.

Vaativampaan käyttöön ja viimeistään Ohjelmointi 2 -kurssilla tarvittavia termejä:

• branch = kehityshaara jossa kehitetään uutta koodia. Kehityshaaroja voi olla useita. Kun koodi on hyväksi todettu, se voidaan yhdistää (merge) päähaaraan.
• tag = jäädytetty haara (esimerkiksi ohjelman tietty versio), jota ei aktiivisesti kehitetä, mutta johon voi tulla esimerkiksi tietoturvapäivityksiä
• HEAD = viite aktiivisen haaran "päähän" tietyssä lokaalissa

Kurssilla käytettäviä Git-komentoja:

git config --global user.name "käyttäjätunnus"
git config --global user.email "%%useremail%%"    
git clone https://gitlab.jyu.fi/käyttäjätunnus/ohj1ht.git .
git status  # tätä komentoa kannattaa käyttää ahkeraan vaikka joka välissä
git log     # samoin tätä, kunhan opit lukemaan sen sisältöä
# tee tarvittavia muutoksia
git add --all
git commit -m "Vaihe 1, kuvat"
git push    # kaverin pitää tämän jälkeen tehdä kotona tehdä git pull
git pull

Ongelmia?

Yleisimpiä ongelmia on lueteltu alla.

{area="vaaraURL" collapse="true" id="v5JVpIErHcLd"} remote: The project you were looking for could not be found or you don't have permission to view it.

Annoit git clone -komennolle väärän etävaraston URL-osoitteen. Tarkista etävarastosi osoite gitlab.jyu.fi-palvelussa oman projektisi kohdasta Clone -> Clone with HTTPS. Anna tämä osoite git clone -komennon perään.

Syy, miksi näin kävi, johtuu todennäköisesti siitä, että forkkia tehdessäsi muutit Project slugia, eli projektin tunnistetta, joka muuttaa etävaraston URL-osoitetta.

{area_end="vaaraURL" id="93Hn2pqIU2AT"}

{area="pushEiOnnistu" collapse="true" id="O95CK3Hj6CQL"} Push ei onnistu (remote: HTTP Basic: Access denied)

Ongelma: Git ei anna viedä mitään etävarastoon (push ei onnistu). Antaa virheilmoituksen:

remote: HTTP Basic: Access denied fatal: Authentication failed for 'https://gitlab.jyu.fi/NIMI/ohj1ht.git'

Huomaa, että virheilmoitus voi näyttää hieman erilaiselta riippuen siitä käytätkö komentoriviä vai jotain muuta Git-asiakasohjelmaa.

Syy (vaihtoehto 1): Etävaraston url-osoitteesta puuttuu lopusta osa .git.

Korjaus: Anna git bashissa / Päätteessä komento git remote -v

Jos fetch- ja push-urlien lopussa ei ole .git-osaa, käy kopioimassa GitLab-palvelussa varastosi HTTPS-url-osoite, ks. kuva alla.

Anna sitten alla oleva komento, ja pasteta URL-kohtaan äsken kopioimasi osoite.

git remote set-url URL

Kokeile nyt tehdä git push.

Syy (vaihtoehto 2): Olet kirjautumisikkunassa kirjoittanut käyttäjätunnuksesi tai salasanasi väärin.

Korjaus Windowsilla: Tarkistetaan käyttäjänimi ja kirjoitetaan salasana uudelleen.

1. Avaa Control panel (ohjauspaneeli).
2. Valitse 'User accounts' (käyttäjätilit).
3. Valitse 'Manage your credentials' (Tunnistetietojen hallinta).

4. Valitse 'Windows credentials' (Windows-tunnistetiedot).

5. Laajentamalla gitin kohtaa, pitäisi päästä muokkaamaan asetettuja käyttäjänimeä ja salasanaa.

Korjaus Mac: Sama homma macOS:ssa (??): https://help.github.com/en/github/using-git/updating-credentials-from-the-osx-keychain

fatal: destination path ‘.’ already exists and is not an empty directory

git clone komennon jälkeen antaa tälläisen:

fatal: destination path ‘.’ already exists and is not an empty directory.

Korjaus: Kun tehdään clone, pitää olla tyhjässä hakemistossa.

'[ht]/' does not have a commit checked out, fatal: adding files failed

Poista projektin hakemistosta .git-kansio. (Huom. älä poista ylätason hakemistosta.) Piilotetut kansiot eivät välttämättä näy tiedostonhallinta-ikkunassa (macOS:lla Finder). Komentorivillä tuon poisto onnistuu esim

rm -rf .git

You can't push or pull repositories using SSH until you add an SSH key to your profile

Syy: Kloonatessasi etävarastoa olet todennäköisesti valinnut SSH-osoitteen HTTPS-osoitteen sijaan.

Suositellaan, että otat tässä kohden työstäsi varmuuskopion.

Korjaus, tapa 1:

1. Kopioi Gitlab-palvelusta (tai muusta palvelusta) tietovarastosi HTTPS-osoite.
2. Avaa komentorivi.
3. Siirry cd-komentoja käyttäen harjoitustyösi kansioon.
4. Anna komentorivillä komento git remote. Näyttöön pitäisi tulostua teksti origin. Mikäli tulostuu jotain muuta, korvaa seuraavassa kohdassa origin-sana sillä, mitä sinulle tulostui.
5. Anna komentorivillä alla oleva komento ja korvaa UUSIOSOITE kohdassa 1 kopioimallasi osoitteella

git remote set-url origin UUSIOSOITE

Korjaus, tapa 2: Jos tapa 1 ei toimi, voit tehdä uuden clonen uuteen kansioon käyttäen HTTPS-osoitetta, ja kopioida aikaisempaan kansioon tekemäsi muutokset tähän uuteen kansioon. Tämän jälkeen pitää tehdä add- ja commit-komennot uudestaan, sen jälkeen push pitäisi onnistua.

Joskus käy niin että Gitissä tulee touhuttua jotakin mikä saa hommat ihan solmuun. Joihinkin probleemiin vastauksia voi löytyä täältä: https://ohshitgit.com/. Ko. saitin kielenkäyttö ei ehkä sovi perheen pienimmille mutta varsinaiset vinkit voivat pelastaa kiperistä tilanteista.

Lisätietoa kiinnostuneille

• Gitin käyttö Ohjelmointi 2 -kurssilla
• Git reference: Git-yhteisön ylläpitämä dokumentaatio Git-komennoille.
• A curious tale - from snaphots to git - tämä ja sen jatko-osa kannattaa lukea, ne selvittävät hyvin Gitin ideaa.
• Pro Git book: Git-yhteisön ylläpitämä Git-kirja.
• Git - Tutorial / Lars Vogel
• Git Handbook
• git - the simple guide
• Helsingin yliopiston Git-kurssi
• ohshitgit - ratkaisuja yleisiin virhetilanteisiin (osittain humoristisia)
• git cheatsheet

Tuki ja palaute

Kevään 2026 ohjauskauden (10.1.-30.4.) aikana on tarjolla seuraavat tukikanavat:

Ohjaukset ovat yhteisiä ITKP102 Ohjelmointi 1- ja ITKA2004 Tietokannat ja tiedonhallinta -opintojaksojen kanssa. Ohjaajat auttavat kummankin kurssin opiskelijoita.

Ohjausaikoja saatetaan lisätä tai poistaa kysynnän mukaan; kerro aikatoiveistasi opettajille sähköpostitse.

Ohjausaikoja saatetaan lisätä tai poistaa kysynnän mukaan; kerro aikatoiveistasi opettajille sähköpostitse.

Ohjeet Teams-ohjauksiin liittymiseksi (tutkinto-opiskelijat)

1. Kirjaudu yliopiston tunnuksellasi Microsoft Teamsiin osoitteessa https://teams.microsoft.com. Käyttäjätunnus on muotoa käyttäjätunnus@jyu.fi (esim. mameikal@jyu.fi). Tunnuksen muoto student.jyu.fi ei käy. Tunnuksen toimiminen vaatii, että olet hyväksynyt Office 365 -palvelut OMA-palvelussa (https://sso.jyu.fi).

2. Lataa Teams-sovellus (suositus) tai käytä nettiversiota. Saatavilla on myös mobiilisovellus. Jos selaimella liittymisessä on ongelmia, tarkista ensin tukeeko Microsoft sitä täältä.

3. Teams-sovelluksessa klikkaa Teams → Join or create team → Join a team with a code

4. Syötä koodi fb8q3qa

5. Testaa kaverin kanssa, että puhelu ja ruudun jakaminen toimii. Sinun tulee tarvittaessa sallia oikeudet käyttöjärjestelmäsi asetuksista.

Ohjeet Teams-ohjauksiin liittymiseksi (avoin yliopisto, erilliset opinto-oikeudet)

Lähetä sähköpostilla alla oleva pyyntö osoitteeseen ohj1-opet@tim.jyu.fi.

Hei,

opiskelen Ohjelmointi 1 -kurssilla ei-tutkintoon johtavassa koulutuksessa.
Pyydän liittämään minut Ohjelmointi 1 -kurssin Teams-ryhmään vieraana. 
Teamsissa käyttämäni sähköpostiosoite on: [oma sähköposti tähän].

Terveisin, [oma nimi]

Liitämme sinut viimeistään seuraavana arkipäivänä.

Etäohjauksiin osallistuminen ilman Teamsia

Jos et millään onnistu kirjautumaan Teamsiin tai et halua olla Teams-kanavalla, voit pyytää etäohjausta Zoomin kautta seuraavasti:

1. Asenna Zoom sovellus koneellesi osoitteesta https://zoom.us/download (muut kuin tutkinto-opiskelijat) tai https://jyufi.zoom.us (tutkinto-opiskelijat; Valitse Download Client ihan alhaalta)
2. Kirjaudu Zoomiin valitsemallasi tilillä, esim. Google-kirjautumista käyttäen (muut kuin tutkinto-opiskelijat) tai Single Sign-on / SSO -toiminnolla (tutkinto-opiskelijat; käytä company domainia jyufi)
3. Aloita kokous New meeting toiminnolla
4. Testaa Audio → Test speaker & mikrofone toiminnolla että äänet pelittää
5. Ota kokouslinkki talteen Participants → Copy invite link
6. Avaa ohjauspyyntölomake: https://forms.gle/5QULUPBHjjqS4ndf6
7. Täytä omat tietosi ja HUOM Pasteta lisätietokenttään kohdassa 5 kopioimasi linkki
8. Odota että ohjaaja tulee huoneeseesi. Saatat joutua hyväksymään hänen sisäänpääsyn (riippuu kokoushuoneesi asetuksista)

Palaute ja kehittäminen

Olemme erittäin kiitollisia kaikesta palautteesta, joka auttaa meitä kehittämään opintojaksoa edelleen! Voit antaa palautetta ja kehitysehdotuksia opintojaksosta kolmella tavalla:

1. Keräämme jatkuvaa palautetta opintojakson aikana. Nyt, kun olemme kehittämässä opintojakson sisältöjä ja toteutusta, tämä jatkuva palaute on erityisen tärkeää. Voit antaa palautetta anonyymisti alla olevan linkin kautta: TODO: Norppa-linkki tähän.

2. Mikäli havaitset materiaalissa virheen, epäselvyyden, tai muun ongelman, voit raportoida siitä GitHubissa klikkaamalla kunkin sivun alareunassa olevia linkkejä. Voit myös ilmoittaa puutteista suoraan opettajille sähköpostitse osoitteeseen ohj1-opet@tim.jyu.fi.

3. Opintojakson lopuksi jokainen Sisussa (tai Ilpo-portaalissa) ilmoittautunut saa henkilökohtaisen linkin kurssipalautekyselyyn, jossa voit antaa anonyymisti palautetta koko opintojaksosta.

Harjoitustyö

Harkkatyön kuvaus. Lomakkeet edelleen TIMissä

Harjoitustyö

• on osa kurssisuoritusta ja arvioidaan asteikolla hyväksytty/hylätty. Harjoitustyö pitää olla hyväksytty ennen kuin kurssista voi saada arvosanan.
• tehdään yksin tai parityönä. Mikäli luontaista paria ei löydy, ei sitä kannata ehkä etsiäkään väkisin. Kolmen hengen ja sitä isompia ryhmiä ei hyväksytä.
• sisältää keskimääräisesti opiskelijaa kohti noin 27 tuntia työtä. Parityönä tehtävän työn määrä on siis laskennallisesti 54 tuntia. Katso tarkat vaatimukset paritöille alla.
• voi olla Jypeli-työkaluilla tehty peli, mutta voi olla jokin muukin C#-kielellä tehty komentoriviohjelma. Muita kieliä ei hyväksytä.

Vaiheet ja aikataulu

Harjoitustyöhön kuuluu kolme vaihetta: Vaihe 1 (suunnitelma), Vaihe 2 (työ 50 % valmis) ja Vaihe 3 (työ 100 % valmis). Vaiheiden tarkemmat kuvaukset löytyvät alta.

Harjoitustyön vaiheet palautetaan esittelemällä ne ohjaajalle. Voit esittää harjoitustyösi ohjauksessa tai sopimalla erillinen ohjausaika sähköpostitse ohj1-opet@tim.jyu.fi.

Aikataulu ja takarajat

Harjoitustyön vaiheiden kuvaukset ja tarkistuslistat

Vaihe 1: Suunnitelma versiohallinnassa

1. Tutkinto-opiskelijat ja lukiolinjat: Suunnitelma on näytettävä ohjaajalle ennen osan 5 harjoitustehtävien takarajaa.

2. Luo oma etävarasto GitLabiin tai GitHubiin. Katso kirjalliset ohjeet tai ohjevideo

3. Kopioi ja liitä etävarastosi osoite Oma eteneminen -sivulle. Etävaraston osoitteen on oltava muotoa https://github.com/nimi/ohj1ht.git TAI https://gitlab.com/nimi/ohj1ht.git. TODO: Linkki.

4. Hae etävarasto omalle tietokoneelle Git-työkalun avulla. Sinulla tulee olla Git-työkalu asennettuna, katso työkaluohjeet. Katso git-ohjeet omien tietojen asettamiseksi ja etävaraston lataamiseksi omalle tietokoneelle.

5. Kirjoita harjoitustyön suunnitelma ladattuun harjoitustyökansioon. Katso suunnitelman vaatimukset alla. Katso esimerkkisuunnitelma.

6. Lataa suunnitelmasi ja kuvasi etävarastoon. Katso ohjeet tiedostojen lisäämiseksi git-varastoon ja ohjeet git-varaston lataamiseksi etävarastoon.

7. Esittele suunnitelma ohjaajalle lähi- tai etäohjauksessa.

Vaihe 2: Työ 50 % valmis

1. Tutkinto-opiskelijat ja lukiolinjat: Harjoitustyön tilanne on näytettävä ohjaajalle ennen osan 8 harjoitustehtävien takarajaa.

2. Tee työsi eteenpäin suunnitelman mukaan.

   • Luo ohjelmakoodia varten uusi solution.
   • Aseta Solution directory-kohtaan sama polku kuin 1. vaiheen Git-varastolla. Esim. C:\kurssit\ohj1\ht.
   • Pidä mielessä suunnitelmasi sekä harjoitustyön vaatimukset.
   • Jos teet harjoitustyön parityönä, muista tehdä tarkaa tuntikirjanpito

3. Varmista, että työsi koodi on ajan tasalla etävarastossa.

   • Katso ohjeet tiedostojen lisäämiseksi git-varastoon (add-commit) ja ohjeet git-varaston lataamiseksi etävarastoon (push).
   • Muista pitää etävarasto ajan tasalla mahdollisimman usein!

4. Esittele suunnitelma ohjaajalle lähi- tai etäohjauksessa.

Jos tämä vaihe on pahasti kesken, tarkastaja palauttaa työn opiskelijalle ja antaa 7 päivää aikaa tehdä korjaukset, jonka jälkeen vaihe tarkastetaan uudelleen.

Vaihe 3: Työ 100 % valmis

1. Tutkinto-opiskelijat ja lukiolinjat: Näytettävä ohjaajalle ensimmäisen tentin mennessä

• Tarkista, että työ täyttää kaikki vaaditut osa-alueet

  • Näet kaikki tarkastettavat osa-alueet vaatimuksista kohdasta "Tarkastettavat osa-alueet"
  • Jos teet harjoitustyön parityönä, tarkista, että tuntikirjanpito on ajan tasalla

• Varmista, että työsi lopullinen koodi on etävarastossa

  • Katso ohjeet tiedostojen lisäämiseksi git-varastoon ja ohjeet git-varaston lataamiseksi etävarastoon
  • Huomaa, että etävarastossa olevan työn tulee olla toimiva! Voit esimerkiksi kokeilla ladata etävarasto omalle tietokoneelle eri kansioon ja yrittää ajaa solution.

• Esittele suunnitelma ohjaajalle lähi- tai etäohjauksessa.

Mikäli ohjaaja antaa merkittävän määrän korjauskehotuksia, opiskelijalla on 7 päivää aikaa tehdä korjaukset, jonka jälkeen vaihe tarkastetaan uudelleen.

Vaatimukset

Suunnitelma

Harjoitustyö täytyy olla suunniteltu ja suunnitelman tulee olla ohjaajan hyväksymä. Suunnitelmat tallennetaan GitLabiin, ks. yläpuolelta vaiheen 1 tarkistuslista.

Suunnitelmassa pitää olla ainakin seuraavat asiat (soveltaen ei-peliharjoitustyöhön):

1. Tekijöiden nimet
2. Pelin nimi
3. Harjoitustyön osoite gitissä
4. Pelaajien lukumäärä (1-4)
5. Pelin taustatarina tai kuvaus pelin teemasta
6. Pelin idea ja tavoitteet
7. Hahmotelma pelistä (kuva tai kuvia paperilla käsin tai tietokoneella piirrettynä)
8. Jonkinlainen kuvaus siitä, miten peli etenee
9. Pelissä olevat oliot, niiden toiminnot ja missä suhteessa ne ovat toisiinsa
10. Toteutuksen suunnitelma: mitä tekisin ja missä järjestyksessä? Millä aikataululla?

Voit katsoa vinkkejä seuraavista esimerkkisuunitelmista:

• Hirsipuu (peli)
• AngryLego (peli)
• Työaikaraportti (ei-peli), katso myös tutoriaali työaikaraporttiin

Toiminnallisuus

Pelissä pitää tapahtua jotakin, eli ruudulla pitää tapahtua jotain järkevää. Käyttäjän tulee voida osallistua peliin interaktiivisesti esimerkiksi hiiren ja/tai näppäimistön välityksellä.

Koodi

Työssä on oltava vähintään muutama aliohjelma Jypelin valmiiden aliohjelmien (Main, Begin) lisäksi.

Muut tarkastettavat osa-alueet on lueteltu alempana kohdassa "Tarkastettavat osa-alueet".

Paritöistä

Kaikki ryhmäläiset käyttävät samaa etävaraston osoitetta. Ks. Git-ohjeet.

Parityöt, työnjako

Molempien on annettava kutakuinkin yhtäläinen panos työn ohjelmalliseen toteutukseen. Yksittäisenä varoittavana esimerkkinä mainittakoon parityö, jossa toinen on paneutunut grafiikan tekemiseen ja toinen ohjelmointiin. Tällöin grafiikkaan paneutuneelta osallistujalta voidaan pyytää lisänäyttöjä työn ohjelmalliseen toteutukseen johon parityön toinen osapuoli ei saa osallistua. Lisäksi kummankin tekijän on pystyttävä esittämään riittävän tarkka tuntikirjanpito ja selvitys mitä työajalla on tehty, jotta osaamistavoitteet ohjelmoinnin osalta voidaan todentaa.

Parityöt, työn vaativuus

Työn on oltava vaativampi kuin yksin tehdyn työn, ja tässä työmäärä on tärkein mittari. Ohjaajat käyvät työn läpi tarkastustilaisuudessa ryhmäläisten kanssa. Yksittäistä pelin ominaisuutta joka kaikilta paritöiltä vaadittaisiin ei yleisellä tasolla voi antaa. Näiden kriteerien tarkoitus ei ole vaikeuttaa tekemistä vaan ehkäistä ennalta vapaamatkustamista.

Tarkastettavat osa-alueet

Alla on tarkastettavien osa-alueiden lista, jonka ohjaajat tulevat tarkastamaan harjoitustyön esittelemisen yhteydessä.

1. Nimeäminen on johdonmukaista ja noudattaa kurssin koodauskäytänteitä.

2. Näkyvyys: Aliohjelmien ja attribuuttien näkyvyys tulee olla määritelty (public, private). Julkisia staattisia (public static) muuttujia ei saa olla.

3. Ei turhia peliluokan attribuutteja.

   Jos joitain koko peliluokkaan näkyviä arvoja tarvitaan, pyritään käyttämään vakioita (const). Kuvat, äänet, animaatiot ja muut raskaat resurssit on kuitenkin hyvä pitää attribuutteina, jolloin ne ladataan vain kerran pelin aikana. Esim. kuvien olioviitteet voi kiinnittää muuttumattomaksi static readonly määreellä.

4. Toimii: Ohjelma toimii, ei kaadu ja päättyy asiallisesti.

   Pelissä pitää tapahtua jotakin järkevää, johon käyttäjä voi osallistua interaktiivisesti. Pelissä pitää myös olla tavoite, haaste tai tarina.

5. Ei toistoa, joka olisi voitu tehdä silmukoilla tai aliohjelmilla.

   Myöskään aliohjelmien välillä ei saa olla toistoa: esimerkiksi LuoVihu1 ja LuoVihu2, joissa olisi lähes sama koodi kahteen kertaan.

6. Taulukko: Käytetään taulukkoa tai listaa.

   Tietorakenteella täytyy olla jokin tarkoitus siten, että sinne tallennetaan useita arvoja, joita todella käytetään pelissä. Tietorakenteen käytön tulee parantaa koodin laatua ja helpottaa koodin lukemista, kirjoittamista tai edelleenkehittämistä. Keinotekoisia tai vailla käyttötarkoitusta olevia tietorakenteita ei hyväksytä. Esimerkkejä.

7. Silmukka: Ainakin yksi silmukka.

   Silmukalla täytyy olla jokin tarkoitus siten, että rakenteen avulla luetaan ja/tai käsitellään tietoa. Ei riitä että lisätään "tähtiä taivaalle silmukassa 10 kpl." Silmukalla tulee olla merkitys, joka parantaa koodin laatua ja helpottaa koodin lukemista, kirjoittamista tai edelleenkehittämistä. Esimerkkejä.

8. Ei turhia literaaleja: Kiinteiden lukuarvojen tai muiden sellaisten arvojen käyttö, jotka heikentävät koodin ylläpidettävyyttä, on kielletty.

   Et siis saa tehdä koodia kuten

   if (y < 18)
   

   jossa 18 on hyvin todennäköisesti turha literaali. Sen tilalle tulee laittaa muuttuja tai vakio, kuten

   int pisteraja = 18
   

   Vakiot ilmaistaan const-määreellä.

9. } + 2 tyhjää: Aliohjelmien loppusulun } jälkeen tasan kaksi tyhjää riviä.

10. Dokumentaatio: Luokat, aliohjelmat ja attribuutit tulee dokumentoida.

    Dokumenteissa kuvataan muun muassa sitä, mitä aliohjelmat tekevät, ei miten ne sen tekevät. Luokan alussa tulee olla tekijän nimi ja versio (@author, @version). Myös attribuutit dokumentoidaan summary-tagein.

11. Funktio: Pelissä on funktio.

    Funktio ottaa vastaan parametrin tai parametreja, käsittelee parametrina saatua tietoa, ja palauttaa arvon annetun syötteen perusteella. Funktion täytyy prosessoida tietoa jotenkin; funktiolla täytyy olla jokin todellinen tarkoitus ohjelman kokonaisuuden kannalta. Tyypillisesti funktiossa voi hyödyntää silmukkaa tai taulukkoa/listaa. Esimerkkejä.

12. Ei virheitä eikä varoituksia Riderin oikeassa yläkulmassa. Muista asentaa kurssin Rider-asetukset

13. Ei-pelien tapauksessa osoitettu myös taito testata aliohjelmia.

Usein kysytyt kysymykset ja muut vinkit

// TODO: taulukko, ks: https://tim.jyu.fi/answers/kurssit/tie/ohj1/%%vuosik%%/demot/demo7?answerNumber=1&task=matriisiensumma&user=vesal

Debuggausnäyte

Debuggauksen kuvaus ja ohjeet. Lomakkeet edelleen TIMissä.

Tentti ja arviointi

Tentin päivät ja arviointi

Luennot

Heippa, maailma!

Harjoituksen päätteeksi sinulla pitäisi olla myös asennettuna kurssin työkalut, sillä kotoa käsin toimiminen edellyttää niiden asentamista. Apua työkalujen asentamiseen saat myös ohjauksissa.

Luennot

Luentojen 1 ja 2 katsominen tukee tätä osaa. Suosittelemme katsomaan luennot ennen tai samanaikaisesti tämän osan lukemisen kanssa.

Tehtävät

Tässä on yhteenveto tämän osan tehtävistä. Tee ne vasta tämän osan lukemisen jälkeen.

👨🏻‍💻 Ensimmäinen ohjelma

Lähdekoodin kirjoittaminen

Tietokoneohjelma on joukko ohjeita, jotka tietokone suorittaa. Ohjelmoija kirjoittaa nämä ohjeet käyttäen ohjelmointikieltä, kuten C#. Tätä kirjoitettua koodia kutsutaan lähdekoodiksi.

Olemme kirjoittaneet sinulle valmiiksi pienen C#-ohjelman, joka tulostaa tekstin "Heippa, maailma!" näytölle. Voit klikata koodilohkon oikeassa reunassa olevaa Play-napin muotoista painiketta ajaaksesi ohjelman. Ohjelman pitäisi näyttää teksti Heippa, maailma!.

public class Ohjelma
{
    public static void Main()
    {
      System.Console.WriteLine("Heippa, maailma!");
    }
}

Tämä on ehkäpä yksinkertaisin mahdollinen esimerkki, mutta silti se on täysin toimivan tietokoneohjelman lähdekoodi (joskaan ohjelma ei ole maailman mielenkiintoisin)! Lupaamme, että opit pian kirjoittamaan monimutkaisempia ohjelmia itse -- mutta aloitetaan pienestä.

Käydään läpi, mitä ohjelma tekee rivi riviltä:

public class Ohjelma

Tämä rivi määrittelee uuden luokan (engl. class) nimeltä Ohjelma. C#-kielessä kaikki koodi kirjoitetaan luokkien sisälle. Luokka on kuin säiliö, joka voi sisältää tietoa ja toiminnallisuutta.

{

Tämä aaltosulku { kertoo, mistä luokan varsinainen sisältö alkaa. Kaikki, mitä luokan sisällä tehdään, kirjoitetaan tämän ja vastaavan sulkevan aaltosulun } väliin.

    public static void Main()

Tämä rivi määrittelee aliohjelman imeltä Main. Tutustumme aliohjelmiin tarkemmin osassa 3, mutta lyhyesti: aliohjelma on joukko ohjeita, jotka suoritetaan, kun aliohjelmaa kutsutaan. Main-aliohjelma on erityinen, koska se on ohjelman aloituspiste -- tietokone alkaa suorittaa ohjelmaa juuri tästä aliohjelmasta.

    {

Vastaavasti kuin luokan kohdalla, tämä aaltosulku kertoo, mistä aliohjelman sisältö alkaa. Kaikki aliohjelman sisällä tehtävä kirjoitetaan tämän ja vastaavan sulkevan aaltosulun } väliin.

        System.Console.WriteLine("Heippa, maailma!");

Tämä rivi on itse asiassa se, joka tekee työn: se tulostaa tekstin "Heippa, maailma!" näytölle. System.Console.WriteLine on C#-kielen sisäänrakennettu toiminto, joka hoitaa tekstin tulostamisen konsoli-ikkunaan. Viesti, joka halutaan tulostaa, kirjoitetaan lainausmerkkien sisälle.

Rivi päättyy puolipisteeseen ;, joka tarkoittaa, että kyseinen lause (engl. statement) on loppu. C#-kielessä lauseet päättyvät tyypillisesti puolipisteeseen. Käymme lauseita tarkemmin läpi osassa 2.2, mutta tässä riittää tietää, että lausetta voi ajatella kuin käskynä tai ohjeena tietokoneelle.

    }
}

Meillä on enää jäljellä kaksi sulkevaa aaltosulkua. Kuten jo mainitsimme, ne kertovat mihin aliohjelma, ja sitten luokka, päättyvät.

Mitä lähdekoodille oikeastaan tapahtuu?

Kun olet kirjoittanut lähdekoodin, se täytyy muuntaa sellaiseen muotoon, että tietokone voi suorittaa sen. C#-kielen kohdalla tätä muodonmuutosta kutsutaan kääntämiseksi (engl. compilation), ja useiden vaiheiden seurauksena syntyy niin sanottu konekielinen ohjelma, joka voidaan käynnistää tietokoneella. Kääntäminen tapahtuu kääntäjällä (engl. compiler), joka on erityinen ohjelma, joka lukee lähdekoodin ja tuottaa siitä suoritettavan ohjelman. Esimerkiksi Rider-sovelluskehitysympäristössä on sisäänrakennettuna toiminnot kääntämistä varten.

Käännetty ohjelma voidaan sitten ajaa (engl. run), eli käynnistää tietokoneella. C#-kielessä kääntämiseen ja ajamiseen tarvitaan .NET-ympäristö, joka sisältää tarvittavat työkalut -- asennusohjeen löydät Työkalut-kohdasta. .NET-ympäristön asentamisen jälkeen kääntäminen-ajaminen–prosessi voidaan tehdä komentoriviltä seuraavasti. Alla on kaksi komentoa, jotka syötetään komentoriville siinä kansiossa, missä projekti on tehty.

Ohjelma on käännettävä aina koodin muuttamisen jälkeen, jotta muutokset tulevat voimaan.

Sovelluskehittimessä (esim. Rider) kääntäminen tapahtuu klikkaamalla Run tai Debug. Noiden painikkeiden painamiseurauksena tapahtuu sekä kääntäminen että ajaminen.

Miten lähdekoodia kirjoitetaan?

Lähdekoodia voi periaatteessa kirjoittaa millä tahansa tekstieditorilla, eli ohjelmalla, jolla voi kirjoittaa ja muokata pelkkää tekstiä ilman erityisiä muotoiluja tai tyylejä. Olet ehkä jo käyttänytkin tekstieditoria, kuten Muistio (Notepad) Windowsissa tai TextEdit macOS:ssä. Tässä "pelkkä teksti" tarkoittaa, että teksti todella tallennetaan tietokoneen muistiin sellaisenaan; esimerkiksi Word-asiakirjaan tallentuu tosiasiassa aina paljon muutakin tietoa, kuten fontti- ja asettelutietoja.

Lähdekoodi tallennetaan tiedostoon, joka C#-kielen tapauksessa päättyy yleensä .cs -tiedostopäätteeseen, kuten Ohjelma.cs. Tällöin käyttöjärjestelmä tunnistaa tiedoston C#-lähdekooditiedostoksi.

Käännösvirheet

Ohjelma ei toimi, jos siinä on virheitä. Virheet luokitellaan yleensä kahteen kategoriaan: käännösaikaisiin virheisiin (engl. compilation errors) ja suorituksen aikaisiin virheisiin (engl. runtime errors).

Käännösvirheet havaitaan siinä vaiheessa, kun ohjelma käännetään lähdekoodista suoritettavaksi ohjelmaksi. Ohjelma ei käänny, jos se sisältää käännöksen estäviä virheitä, kuten syntaksivirheitä. Tällöin kääntäminen ei onnistu eikä ohjelmaa voi ajaa. Virheet on korjattava ennen uutta kääntämistä. Käännösvirheet näkyvät kääntäjän antamina virheilmoituksina. Esimerkiksi Rider-sovelluskehittimessä virheet näkyvät alareunassa olevassa Errors-välilehdessä.

Alla olevassa ohjelmassa on virhe. Klikkaa Play-painiketta nähdäksesi virheilmoitukset.

public class Ohjelma
{
    public static void Main()
    {
      System.Console.WriteLine("Heippa, maailma!"
    }
}

Kääntäjä kertoo, että rivillä 5 sarakkeessa 50 on virhe, jonka syynä on puuttuva sulku ). Kääntäjä kertoo, että ohjelmassa on toinenkin virhe: riviltä 5 puuttuu myös puolipiste ;. Käännösvirheeseen tulostuu aina paitsi rivi- ja sarakenumero, myös C#:n virhekoodi (tässä CS1026 ja CS1002), ja lyhyt kuvaus virheestä. Korjaa nämä virheet yllä olevassa koodausikkunassa lisäämällä puuttuvat merkit, että saat virheilmoitukset katoamaan, ja ohjelma käännettyä onnistuneesti.

Suorituksenaikaiset virheet puolestaan ilmenevät vasta ohjelman ajon aikana, jos ohjelma kohtaa tilanteen, jota se ei osaa käsitellä. Esimerkiksi jakaminen nollalla on virhe, joka ilmenee (vasta) ohjelman suorituksen aikana. Jos ohjelma yrittää suorittaa tällaisen operaation, ohjelma kaatuu suorituksen aikana.

public class Ohjelma
{
    public static void Main()
    {
      int a = 10;
      int b = 0;
      int c = a / b;
      System.Console.WriteLine("Tulos: " + c);
    }
}

📝 Tehtävät

Jyväskylän yliopisto
Informaatioteknologian tiedekunta

🛠️ Ohjelmointiympäristö kuntoon

Ensimmäisten viikkojen tehtävät voi periaatteessa suorittaa verkkoselaimessa, mutta varsin pian on tarpeen saada oma ohjelmointiympäristö toimimaan tietokoneella.

Oman tietokoneen käyttöönottaminen ohjelmointia varten on tärkeä askel kohti itsenäisempää ohjelmointia. Se mahdollistaa esimerkiksi koodin kirjoittamisen, tallentamisen ja suorittamisen ilman internet-yhteyttä. Lisäksi omaa ympäristöä on helpompi mukauttaa omien tarpeiden mukaan, kuten vaihtaa värejä, fontteja ja muita asetuksia. Myöhemmin opit käyttämään versionhallintaa sekä debuggausta, jotka vaativat ohjelmointiympäristön omalla tietokoneellasi.

Rider

Ohjelman koon kasvaessa kannattaa ottaa käyttöön sovelluskehitin eli IDE (Integrated Development Environment). IDE on ohjelma, joka yhdistää yhteen paikkaan kaikki ohjelmien kehittämiseen tarvittavia ominaisuuksia, kuten:

• koodin kirjoittaminen
• koodin kääntäminen ohjelmaksi
• virheiden ja ongelmien etsiminen koodissa
• koodin navigointi- ja refaktorointityökaluja (esim. "Etsi koodista", kirjoittamisen aikaiset ehdotukset, koodin massamuokkaaminen)
• ohjelman virheiden jäljitys eli debuggaus
• samaan asiakokonaisuuteen liittyvän koodin hallinta ("projektit")
• versionhallinnan tuki (esim. Git)

IDE-ympäristöjä on useita eri ohjelmointikielille ja ympäristöille. Ohjelmointi 1 -opintojaksolla käytetään JetBrains-yhtiön tekemää Rider-kehitysympäristöä, joka on erityisesti C# ja .NET-ajoympäristölle tarkoitettu IDE. Riderilla voi tehdä niin tekstipohjaisia sovelluksia kuin Jypeli-pelejäkin.

Riderin asennusohjeet löytyvät Työkalut-sivulta.

Sivuhuomiona mainittakoon, että kaikenlaiset pilvipalvelut ovat yleistyneet, ja myös pilvipohjaisia kehitysympäristöjä on olemassa. Kuitenkin edelleen yleinen käytäntö ohjelmoinnin opiskelussa, kuten myös Ohjelmointi 1 -kurssilla, on asentaa kehitysympäristö omalle paikalliselle tietokoneelle. Oman kehitysympäristön käyttö on yleensä nopeampaa, edullisempaa ja joustavampaa kuin pilvipohjaiset ratkaisut. Myös työelämässä paikalliset kehitysympäristöt ovat yleensä vallitseva käytäntö.

Visual Studio Code

Vaihtoehtoisesti voit käyttää myös Visual Studio Code -editoria (lyhyesti VS Code), joka on hyvin suosittu tekstieditori, jota voi käyttää myös IDE:nä. VS Coden asennusohjeet löytyvät myöskin Työkalut-sivulta.

Alla olevat ohjeet koskevat kuitenkin vain Rideria.

Konfigurointi ja laajennokset

Oletusasetukset koodin muotoilulle ja analysoinnille ovat tämän kurssin näkökulmasta usein turhan aggressiivisia (ts. auttavat turhan innokkaasti tai väärään suuntaan), joten muutetaan asetuksia tämän kurssin suositusten mukaisiksi.

Jos haluat varmuuskopioida nykyiset asetuksesi, tee se valikosta File → Manage IDE Settings → Export Settings.

• Lataa asetuspaketti (settings.zip) (Linuxissa voi joutua vaihtamaan tarkentimen .jar latauksen jälkeen)
• Avaa Rider ja valitse Welcome to JetBrains Rider-ikkunassa vasemmasta alalaidasta Configure → Import Settings...
• Etsi ja valitse äsken haettu tiedosto
• Klikkaa OK, sitten Import and Restart

Vaihtoehtoisesti voit mukauttaa asetuksia yksitellen alla olevien ohjeiden mukaisesti.

Ja uusimmassa Riderissa joudut joka tapauksessa alla olevalla manuaaliohjeella poistamaan oikoluvun käytöstä (ainakin toistaiseksi).

Sisäänrakennetun tekoälytäydennyksen kytkeminen pois

Riderissa on sisäänrakennettu tekoälypohjainen täydennys, joka yrittää täydentää kirjoitetun rivin loppuun ympäröivän koodin perusteella:

Aivan opintojakson alussa tämä täydennys ei haittaa, mutta myöhemmin täydennys pikemmin häiritsee sen rajoittuneisuuden vuoksi. Siispä suosittelemme kytkemään se pois seuraavasti:

• Avaa Rider Welcome to JetBrains Rider -näkymään
• Valitse vasemmasta alalalaidasta Configure → Settings
• Mene asetuksissa kohtaan Editor → General → Inline Completion
• Ota ruksi pois kohdasta Enable local Full Line completion suggestions
• Tallenna asetukset Save-painikkeella

Riderin peruskäyttö: solution ja projekti

Rider käyttää ns. solution-projekti-rakennetta koodin organisointiin.

Projekti sisältää yhteen ohjelmaan (peliin tai konsolisovellukseen) liittyvän koodin ja grafiikka- ja musiikkitiedostot.

Projekti kuuluu aina johonkin solutioniin. Yksi solution voi sisältää yhden tai useampia projekteja.

Sivuhuomiona mainittakoon, että solution on Microsoftin keksimä nimi tällaiselle projekteja koostavalle kapistukselle. Sana ei varsinaisesti tarkoita mitään.

Esimerkiksi yksi demokerta voi olla yksi solution joka sisältää useita projekteja (demotehtäviä). Useiden projektien lisäämisessä samaan solutioniin on se etu, että silloin voi pitää samaan demoon liittyvät tehtävät yhtä aikaa näkyvillä ilman että niitä tarvitsee jatkuvasti avata tai sulkea.

Riderissa tehdyt solutionit ja projektit ovat yhteensopivia Visual Studion kanssa.

Suositeltava hakemistorakenne

Kurssilla kannattaa kaikki kurssin asiat tehdä esimerkiksi alikansion (hakemiston) ohj1 alle. Tuo ohj kansio ohj1 voi alla käyttötarkoituksesta riippuen eri paikassa:

Mikroluokan koneessa

c:\MyTemp\<käyttäjätunnus>\ohj1

ja omassa kannettavassa esimerkiksi:

Windows: `/c/kurssit/ohj1`    
Mac ja Linux: `~/kurssit/ohj1` 

ja sitten tuon kansion alla on alikansiota tyyliin:

ohj1
 |
 +-demot 
 |  +-demo1
 |  | +-HelloWorld
 |  | +-Lumiukko
 |  | 
 |  '-demo2
 |    +-Lumiukko2
 |    +-LukujenLaskemista
 |
 '-ohjaukset
    +-paate1
    | +-HelloWorld
    | +-Lumiukko
    '-paate2

Eli esimerkiksi demo1 on yksi solution jonka alla on useita projekteja. Usein projekti on yksi demotehtävä.

Uusi solution

Luodaan uusi solution ja siihen projekti. Tässä esimerkissä luodaan demo1-niminen solution ja siihen Lumiukko-niminen projekti demot-alikansioon:

Mikäli haluat lisätä projektin olemassa olevaan solutioniin, katso luku Uusi projekti olemassa olevaan solutioniin.

• Valitse New Solution. Mikäli joku vanha solution on jo auki, niin sama onnistuu yläpalkista File/New Solution.

• Valitse vasemmalta Custom templates -listasta FysiikkaPeli.

• Anna solutionin nimeksi demoX, esimerkiksi demo1

• Anna projektin nimi, esimerkiksi Lumiukko tai Teht3Lumiukko (Huom Iso alkukirjan!).

• Kirjoita tai selaa poluksi (<käyttäjätunnus> tilalle oma käyttäjätunnuksesi jos se on eri):

  • oma Windows kone: C:\kurssit\ohj1\demot
  • Mac: /Users/<käyttäjätunnus>/kurssit/ohj1/demot
  • Linux: /home/<käyttäjätunnus>/kurssit/ohj1/demot
  • mikroluokssa C:\MyTemp\<käyttäjätunnus>\ohj1\demot HUOM! Yliopiston mikroluokissa projekti tulee tehdä ensin tietokoneen kiintolevylle, esim. C:\MyTemp\<käyttäjätunnus>\.... Siirrä lopuksi tiedostot U-asemallesi tai muualle talteen.

• Jätä Put solution and project in the same directory-boksi tyhjäksi.

• Framework-kohtaan net8.0

• Klikkaa Create.

• Levylle syntyy nyt hierarkia:

        kurssit                    - kaikkien kurssien hakemisto
          ohj1                     - ohj1 kurssin hakemisto
            demot                  - demojen hakemisto
              demo1                - demo1:n hakemisto
                demo1.sln          - solutionintiedosto jossa luetellan mitä projekteja
                Lumiukko           - hakemisto jonka alla Lumiukko-projekti     
                  bin              - hakemisto jonne tulee ajettavaa koodia
                  obj              - hakemisto jonne tulee käännettyjä tiedostoja
                  Lumiukko.cs      - C#-tiedosto johon tulee lumiukon piirtävä koodi
                  Ohjelma.cs       - C#-pääohjelma
                  Lumiukko.csproj  - projektin tiedosto jossa kerrotaan mitä tiedostoja
                                     projektiin liittyy
  

• Klikkaa Solution Explorerissa Lumiukko.cs-kooditiedostoa. Koodissa pitäisi näkyä:

  public class Lumiukko : PhysicsGame
  {
      public override void Begin()
      {
          // Kirjoita ohjelmakoodisi tähän
  
          PhoneBackButton.Listen(ConfirmExit, "Lopeta peli");
          Keyboard.Listen(Key.Escape, ButtonState.Pressed, ConfirmExit, "Lopeta peli");
      }
  }
  

• Kokeile käynnistää ohjelma Run/Run 'Lumiukko', jolloin pitäisi näkyä uusi ikkuna vaaleansinisellä taustalla. Jos kaikki toimii, sulje ikkuna.

• Pyyhi pois koko se rivi jossa lukee "Kirjoita ohjelmakoodisi tähän" ja kirjoita tilalle

          Level.Background.Color = Color.Black;
          PhysicsObject pallo = new PhysicsObject(200, 200, Shape.Circle);
          pallo.Color = Color.White;
          Add(pallo);
  

• Käynnistä ohjelma uudestaan ja tarkista että ohjelma muuttui.

• Kirjoita luokan dokumentaatiokommentti näppäilemällä luokan esittelyrivin (elipublic class...) yläpuolelle kolme kauttaviivaa ///. Kirjoita <summary>-tagien väliin selvitys luokan toiminnasta (eli että piirretään lumiukko)

• Kirjoita vastaavasti Begin-metodin dokumentaatiokommentit.

Uusi projekti olemassa olevaan solutioniin

Oletetaan, että solution on jo olemassa. Lisätään siihen toinen projekti olemassa olevan lisäksi. Tässä esimerkissä luodaan uusi ConsoleMain-projekti olemassa olevaan demo1-solutioniin.

• Klikkaa Explorer-paneelissa solutionin demo1 nimeä hiiren oikealla (Macissa kahdella sormella).
• Valitse Add -> New Project
• Valitse vasemmalta ConsoleMain-projektimalli
• Anna nimeksi HelloWorld
• Paina Create.
• Ensimmäisellä kerralla projekti ajetaan klikkaamalla Explorerissa sen nimeä HelloWorld hiiren oikealla ja valitse Run HelloWorld. Myöhemmillä kerroilla voit käynnistää projektin käynnistämällä yläpalkista haluamasi projektin.

Jypeli-projektit

Jypeli-projektin voi tehdä valitsemalla solutionia tai projektia luodessa Custom Templates -kohdasta oikean projektimallin.

• ConsoleMain (Konsolisovellukset, joissa on Ohj1 kurssin pohja)
• Fysiikkapeli (Fysiikkaa käyttävät pelit ja muut graafiset sovellukset)
• Tasohyppelypeli (Esimerkkipeli)
• Android Fysiikkapeli (Android-alustaa varten)

Pääohjelma Jypeli-projekteissa (Main)

Jypeli-projektissa Main-pääohjelma menee Ohjelma.cs-tiedostoon, joten jos copy-pastetat koodin, joka sisältää Main-pääohjelman, niin poista Main-pääohjelma Portaat-luokan (tms. projektisi nimeä vastaava luokka) sisältä. Projektissa ei saa olla kahta Main-pääohjelmaa.

Sisällön tuominen Jypeli-projektiin (Content-kansio)

Kuvat ja äänet lisätään peliprojektin Content-kansioon, joka näkyy editorin tiedostolistauksessa.

Content-kansion voi luoda klikkaamalla hiiren oikealla projektia → Add → Directory

1. Lisää tiedosto klikkaamalla kansiota hiiren oikealla napilla → Add → Add Existing Item
2. Valitse tiedosto(t) jonka haluat lisätä ja paina ok.
3. Valitse Copy.
4. Klikkaa tuomaasi tiedostoa Content-kansiossa hiiren oikealla ja valitse Properties
5. Vaihda Copy to output directory -kohtaan "Copy if newer"

Graafinen sovellus Jypeli-kirjastolla

Jypeli on C#-kielellä kirjoitettu pelimoottori, joka on suunniteltu erityisesti opetuskäyttöön. Jypeli tarjoaa helppokäyttöisen tavan pelien luomiseen, mikä tekee siitä hyvän valinnan tälle kurssille.

Jypelin avulla voi luoda 2D-pelejä, joissa on grafiikkaa ja ääniä. Jypeliin on tarjolla paljon valmiita ohjeita ja esimerkkejä TODO: Linkki, jotka auttavat sinua pääsemään alkuun pelien tekemisessä.

Tehdään seuraavaksi pieni Jypeli-esimerkki, jossa luodaan ikkuna ja piirretään siihen ympyrä.

using Jypeli;
public class YmpyraPeli : PhysicsGame
{
    public override void Begin()
    {
        GameObject ympyra = new GameObject(50, 50);
        ympyra.Shape = Shape.Circle; 
        ympyra.Position = new Vector(0, 0); // Asetetaan ympyrä keskelle ikkunaa
        Add(ympyra); // Lisätään ympyrä peliin
    }
}

Voit käynnistää pelin yllä klikkaamalla oikean yläreunan vihreää "Play"-painiketta. Ikkunaan pitäisi ilmestyä keskelle pieni ympyrä.

Huh! Siinä oli jo aika paljon uutta. Käydään koodi läpi vaiheittain.

Ensimmäinen rivi luo uuden muuttujan nimeltä ympyra, joka on tyyppiä GameObject. Sen leveydeksi ja korkeudeksi annetaan 50.

GameObject ympyra = new GameObject(50, 50);

Seuraavaksi asetamme ympyra muuttujan muodoksi Shape.Circle ja sijainniksi asetetaan vektori, joka osoittaa keskipisteeseen new Vector(0, 0).

ympyra.Shape = Shape.Circle; // Asetetaan muodoksi Shape.Circle
ympyra.Position = new Vector(0, 0); // Asetetaan ympyrä keskelle ikkunaa

Lopuksi lisäämme ympyra muuttujan näkyviin kutsumalla Jypelin Add metodia. ympyra muuttuja on siis olemassa jo heti ensimmäisen rivin jälkeen, mutta se pitää erikseen vielä lisätä "pelimaailmaan".

Add(ympyra); // Lisätään ympyrä peliin

Tehtävät

Asenna Rider ja Jypeli omalle tietokoneellesi Työkalut-sivulla olevia ohjeita noudattaen.

🔢Tiedon esittäminen tietokoneessa

Tietokoneen muistiin tallennetaan lukuja kaksijärjestelmässä eli ns. binäärimuodossa. Tietokoneen muisti koostuu biteistä, jotka voivat olla joko 0 tai 1. Myös lähdekoodimme teksti ja kaikki tieto on oltava lopulta bittimuodossa, jotta tietokone pystyy käsittelemään sitä.

Syy, miksi tietokoneet käyttävät juuri binäärimuotoa piilee tietokoneiden rakenteessa: prosessorit ja muistit on rakennettu kytkimistä, jotka pystyvät luotettavasti erottamaan kaksi tilaa, kuten jännitteisen ja jännitteettömän tilan, jotka voidaan esittää binääriluvuilla 0 ja 1. Vaikka tällainen esitystapa saattaa vaikuttaa yksinkertaiselta tai jopa kömpelöltä, se on erittäin luotettava ja tehokas tapa käsitellä tietoa sähköisissä järjestelmissä.

On hyvä ymmärtää, miten tekstiä, lukuja ja muuta informaatiota esitetään tietokoneessa, jotta voi paremmin hahmottaa ohjelmointia ja tietokoneen toimintaa. Informaation tallennus- ja esitystapa kytkeytyy esimerkiksi ohjelman suorituskykyyn. Myöhemmin opinnoissa tulet törmäämään myös tietoturvaan liittyviin asioihin, joissa tiedon esitystavalla on merkitystä.

Kokonaislukujen esittäminen binäärimuodossa

Siinä missä kymmenjärjestelmässä (kutsutaan usein myös desimaalijärjestelmäksi) on kymmenen eri numeroa, 0-9, kaksijärjestelmässä on vain kaksi eri numeroa: 0 ja 1. Luvun paikka määrittää sen arvon: esimerkiksi 345 tarkoittaa $3\cdot 10^2+4\cdot 10^1+5\cdot 10^0$. Voidaan ajatella, että jokaisella luvulla on paikka, joka kertoo sen arvon potenssina kymmenelle (alkaen oikealta, ensimmäinen paikka on 0). Esimerkiksi luvun 345 kohdalla luku 5 on paikassa 0, luku 4 paikassa 1 ja luku 3 paikassa 2.

Vastaava idea toimii myös kaksijärjestelmässä. Kaksijärjestelmässä luvun paikka määrittää sen arvon kahden potenssina: esimerkiksi binääriluku 101 tarkoittaa $1\cdot 2^2+0\cdot 2^1+1\cdot 2^0=5$ kymmenjärjestelmässä.

Kun luku halutaan tallentaa tietokoneeseen, on ensiksi on sovittava kuinka monta bittiä on käytetään luvun esittämiseen. Käytämme alla olevissa esimerkeissä 8-bittisiä lukuja, jotta luvut pysyvät yksinkertaisina.

Esimerkiksi luku 7 on 8-bittisessä binäärimuodossa 00000111, koska

$7=0\cdot 2^7+0\cdot 2^6+0\cdot 2^5+0\cdot 2^4+0\cdot 2^3+1\cdot 2^2+1\cdot 2^1+1\cdot 2^0$

Negatiivisten lukujen esittämiseen käytetään yleisesti nk. kahden komplementin menetelmää. Kahden komplementin menetelmässä negatiivinen luku saadaan kääntämällä ensin luvun kaikki bitit (0 -> 1 ja 1 -> 0) ja lisäämällä sitten tulokseen 1.

Negatiivinen luku -7 voidaan esittää kahden komplementin avulla lukuna 11111001. Luku saadaan seuraavasti:

7 = 00000111
// Käänteisluku
~7 = 11111000
// Lisätään 1
~7 + 1 = 11111001

Tosiasiassa 8-bittisiä lukuja käytetään harvoin, ja useimmiten käytetään 32-bittisiä (C#:ssa int) tai 64-bittisiä (long) lukuja. Vastaava ajatus pätee kuitenkin myös näihin suurempibittisiin lukuihin.

Desimaalilukujen esittäminen binäärimuodossa

Desimaaliluvut esitetään tietokoneessa liukulukuna IEEE 754 -standardin mukaisesti. Liukuluvut voivat olla myös erikoisarvoja, kuten NaN (Not a Number) ja Infinity. Liukuluvut ovat likiarvoja, vaikkakin käytännössä jotkin niistä ovat tarkkoja arvoja (kuten luku 1.0).

Esimerkiksi lukua 0.1 ei voida esittää täsmällisesti liukulukuna, koska kaksiarvoisessa järjestelmässä 0.1 on äärettömän pitkä desimaaliluku.

Tekstin esittäminen binäärimuodossa

Tekstin esittämiseen tietokoneessa on olemassa erilaisia merkistöjä ja merkistökoodauksia. Yksi niistä on ASCII (engl. American Standard Code for Information Interchange).

ASCII on sopimus, joka määrittää 128 merkille (mm. aakkoset a-z ja numerot 0-9) yksikäsitteisen numeroarvon väliltä 0-127. Tämän numeroarvon avulla merkki voidaan esittää binäärimuodossa, tallentaa tietokoneen muistiin ja myös lukea sieltä. Esimerkiksi kirjain 'A' on ASCII-koodissa 65, 'B' on 66 jne.

ASCII-koodi on yhä kaikkien modernien koodausten perusosa. (Koodauksella tarkoitetaan tässä yhteydessä merkistön esitystapaa tietokoneessa.) Pelkkä ASCII on kuitenkin sinänsä rajoittunut. Nykyisin oletuskoodaus on useimmiten UTF-8 (Unicode-standardi), joka on taaksepäin täysin yhteensopiva ASCII:n kanssa, joka sisältää käytännössä kaikki maailman kirjoitusjärjestelmät. Ohjelmakoodin kirjoittamisessa käytetään edelleen usein 7-bittisiä ASCII-merkkejä, vaikkakin Unicode-merkit ovat sallittuja monissa ohjelmointikielissä.

Unicode-merkkien määrä on valtava verrattuna ASCII-koodiin: niitä on yli miljoona. Unicode-merkit esitetään yleensä 16-järjestelmän lukuna, eli ns. heksadesimaalina, kuten U+0041 (luku 65, eli kirjain 'A').

Tehtävät

Osan kaikki tehtävät

Osa 2

Katso luennot 3 ja 4

Tämän osan aiheita ovat:

• muuttujat ja tietotyypit
• lausekkeet ja lauseet
• ohjelman rakenne ja suoritusjärjestys
• aliohjelmat
• kommentointi ja dokumentointi

📦 Muuttujat ja tietotyypit

🛝 Lausekkeet ja lauseet

Kommentointi ja dokumentointi

Kommentointi

Tehtävät

Tässä on lueteltu kaikki tähän osaan kuuluvat tehtävät.

Tee TIMissä... Linkki...

🏗️ Ohjelman rakenne

C#-kieli on olioperusteinen ohjelmointikieli, mikä tarkoittaa, että kaikki koodi kirjoitetaan luokkien sisälle. Jokaisessa ohjelmassa täytyy tavallisesti olla vähintään yksi luokka. Luokassa tulee olla Main-aliohjelma, joka toimii ohjelman aloituspisteenä -- siksi sitä kutsutaan myös pääohjelmaksi. Ohjelma suoritetaan järjestyksessä, lause kerrallaan ylhäältä alaspäin Main-aliohjelmasta alkaen. Luokka voi sisältää muitakin aliohjelmia. Pääohjelma voi kutsua aliohjelmia, jotka voivat kutsua taas muita aliohjelmia jne. Ohjelman suoritus päättyy, kun pääohjelma on suoritettu loppuun.

Puhumme aliohjelmista osassa 3.1 Aliohjelmat; tässä osassa keskitymme kuitenkin ohjelman rakenteeseen kokonaisuutena.

Alla oleva sovellus koostuu yhdestä luokasta, joka sisältää pääohjelman ja yhden aliohjelman (Tervehdys), siis yhteensä kaksi aliohjelmaa. Käytäntö on, että yksi tiedosto sisältää yhden luokan, ja että luokan nimi on sama kuin tiedoston nimi.

using System;

public class Sovellus
{
  public static void Main()
  {
    // Ohjelman suoritus alkaa Main-aliohjelmasta
    // Tässä kutsutaan Tervehdys-aliohjelmaa kaksi kertaa
    Tervehdys();
    Tervehdys();
  }

  public static void Tervehdys()
  {
     Console.WriteLine("Tervehdys!");
  }
}

System.Console.WriteLine("Hello, World!");

🛝 Lauseet ja lausekkeet

Lauseet ja lausekkeet ovat eräitä ohjelman perusyksiköitä. Lauseen (engl. statement) seurauksena tapahtuu jotakin, kun taas lauseke (engl. expression) on asia, jonka arvo voidaan laskea.

Lause voi olla esimerkiksi muuttujan määrittely, aliohjelman kutsu, ehto- tai toistolause, ja näitä suoritetaan yksi kerrallaan. Lauseilla ohjataan ohjelman suoritusta. Lause voi sisältää lausekkeen (tai lausekkeita), mutta sen päätehtävä on suorittaa jokin toiminto (esim. muuttujan määrittely, arvon asettaminen, silmukan käynnistäminen tai ehtolauseen tarkistaminen).

Lausekkeilla tuotetaan arvoja. Lauseke voi sisältää esimerkiksi matemaattisia laskutoimituksia, muuttujia, funktiokutsuja tai niiden yhdistelmiä. Näiden tavoitteena on tuottaa ohjelmaan jokin arvo, joka voidaan toimittaa ohjelmassa eteenpäin jatkojalostettavaksi.

// Lause, joka määrittelee muuttujan a. 
// Luku 3 on lauseke -- toki hyvin yksinkertainen sellainen.
int a = 3;     
// Lause, joka lisää muuttujan a arvoa yhdellä
a++;
// Lause, jossa b saa lausekkeen a + 5 arvon, eli 9.
int b = a + 5; 

// if-lause
if (a > 5) // lauseke a > 5
{
  // ...
}

Lauseke voi olla myös aliohjelmakutsu, joka palauttaa arvon. Alla Keskiarvo-aliohjelman kutsu on esimerkki lausekkeesta, kuten myös tulostuslause.

int a; 
a = Keskiarvo(3, 5); // Sijoituslause, jossa a saa
                     // Keskiarvo-aliohjelman paluuarvon
Console.WriteLine($"Muuttujan a arvo on {a}");

Kuten mainittiin, lauseet voivat sisältää lausekkeita. Lausekkeet eivät yleensä sisällä lauseita, mutta tähänkin on hassuja poikkeuksia.

int a = 3;
int b = 5;
if (a++ < b) // a++ < b sisältää sekä lausekkeen että lauseen
{
   // ...
}

Tässä esitetty jako lausekkeisiin ja lauseisiin on yksinkertaistus. Se, mihin "lokeroon" jokin koodinpätkä kuuluu, vaihtelee ohjelmointikielen mukaan. Ohjelmointikielen spesifikaatio määrittelee sen, mitkä koodinpätkät ovat lauseita, mitkä lausekkeita, ja mitkä jotakin muuta. Jos asia kiinnostaa enemmän, voit tutustua 📖 C#-kielen spesifikaatioon.

Arvojen laskeminen

💾 Muuttujat ja tietotyypit

Muuttujat ovat ohjelmassa käytettäviä arvoja, joiden arvo voi muuttua ohjelman suorituksen aikana. Niinpä voidaan sanoa, että ohjelman tila koostuu muuttujissa olevista arvoista. Jos muuttujan arvo muuttuu (esimerkiksi käyttäjän vuorovaikutuksen seurauksena), muuttuu ohjelman tila.

C#-kielessä jokaiselle muuttujalle on määriteltävä nimi ja tyyppi ennen käyttöä. Muuttujan tyyppi määrittää tarkasti, millaisia arvoja siihen voi tallentaa. Jos ohjelmoija yrittää tallentaa muuttujaan väärän tyyppisen arvon, kääntäminen epäonnistuu. Valittua tyyppiä ei voi muuttaa ohjelman suorituksen aikana; muuttujan tyyppi säilyy samana koko muuttujan elinkaaren ajan.

Määritellään seuraavassa esimerkissä kolme muuttujaa ja sijoitetaan kuhunkin niihin sopiva arvo.

int luku = 5; // luku-muuttujaan voi tallentaa kokonaislukuja
string nimi = "Maija"; // nimi-muuttujaan voi tallentaa merkkijonoja
bool onkoTosi = true; // onkoTosi-muuttujaan voi tallentaa totuusarvoja

Ensimmäinen muuttuja nimeltä luku on tyypiltään int, eli kokonaisluku. Muita kokonaislukuja voisivat olla esimerkiksi -10, 0 ja 67.

Toinen muuttuja nimeltä nimi on tyypiltään string, eli merkkijono. Merkkijono voi sisältää esimerkiksi kirjaimia, numeroita ja erikoismerkkejä. Esimerkkejä merkkijonoista ovat "Hei!", "12345" ja "Ohjelmointi on kivaa.". Huomaa, että merkkijonot kirjoitetaan lainausmerkkien sisälle.

Kolmas muuttuja nimeltä onkoTosi on tyypiltään bool, eli totuusarvo. Totuusarvo voi olla joko true (tosi) tai false (epätosi). Esimerkkejä totuusarvoista ovat esimerkiksi 5 > 3 (joka on tosi) ja 2 == 4 (joka on epätosi).

Perustietotyypit

Yllä olevassa esimerkissä käytetyt int, string ja bool ovat C#-kielen perustietotyyppejä (engl. primitive data types). Alla on lueteltu C#:n perustietotyypit ja niiden tärkeimmät ominaisuudet:

Lukutyypit:

Muut tietotyypit:

| Tietotyyppi | Kuvaus | Esimerkkejä arvoista | | string | Merkkijono | | "Hei!", "12345" | | bool | Totuusarvo | true, false | | char | Yksittäinen merkki | 'a', '1', '#' |

Vakiot

Vakio on muuttuja, jonka arvo vakioidaan käännöksessä, eikä arvoa voi muuttaa ohjelman suorituksen aikana. Vakio määritellään const-avainsanalla.

const int MONTAKO_VIHUA = 10; // all caps -tyyli
const string TervehdysSana = "Hei"; // PascalCase-tyyli

Vain sellainen tietotyyppi, jonka arvo voidaan laskea käännösaikana, voidaan määritellä vakioksi. Esimerkiksi oliotietotyypit (esim. int[]) ovat niin kutsuttuja viitetyyppejä (engl. reference types), eikä niitä voida määritellä const-avainsanalla. On olemassa muuttumattomia oliotietotyyppejä (esimerkiksi ImmutableArray), mutta emme käsittele niitä tällä kurssilla, joskin string-tyyppi tekee tähän poikkeuksen.

✨ Valinnaista lisätietoa: Oliot, joiden arvot määräytyvät vasta ajon aikana, voidaan määritellä readonly-avainsanalla. Tällöin muuttujan arvo voidaan asettaa vain kerran. Tämä vastaa kutakuinkin yllä mainittujen perustietotyyppien const-avainsanaa.

Osan kaikki tehtävät

Osa 3

Katso luennot 5 ja 6

Tämän osan aiheita ovat...

• ehtolauseet
• vertailuoperaattorit
• loogiset operaattorit

Tehtävät 2.4--2.7

Tee TIMissä (linkki)

🧩 Aliohjelmat

Aliohjelmat ovat ohjelman osia, jotka suorittavat tietyn tehtävän. Aliohjelmat helpottavat ohjelman rakentamista pienistä palasista, sekä ohjelman ylläpitoa. Aliohjelmat mahdollistavat koodin uudelleenkäytön, sillä aliohjelma voidaan määritellä kerran ja käyttää (eli kutsua) sitä useita kertoja.

Määrittely. Ennen aliohjelman käyttöä se tulee määritellä. Määrittelyssä kerrotaan aliohjelman nimi, mahdolliset parametrit, paluuarvon tyyppi sekä julkisuus. Nämä tiedot kertovat, miten (ja mistä) aliohjelmaa voidaan käyttää.

Alla on esimerkki aliohjelman määrittelystä:

public static void OmaAliohjelma()
{
    Console.WriteLine("Tämä on aliohjelma!");
}

• public tarkoittaa, että aliohjelma on julkinen ja sitä voidaan kutsua mistä tahansa ohjelman osasta.
• static tarkoittaa, että aliohjelma kuuluu luokalle eikä oliolle. static-avainsanaa käsitellään tarkemmin Ohjelmointi 2 -kurssilla.
• void tarkoittaa, että aliohjelma ei palauta arvoa. Jos aliohjelma palauttaisi arvon, void-sanan tilalla olisi jokin muu tietotyyppi, kuten int, string tai bool.
• OmaAliohjelma on aliohjelman nimi.
• Sulkeiden () sisällä olisi mahdolliset parametrit, joita aliohjelma ottaa vastaan. Tässä esimerkissä aliohjelma ei ota parametreja.

Voimme nyt kutsua aliohjelmaa ohjelman muista osista:

public static void Main()
{
    OmaAliohjelma(); // Kutsuu aliohjelmaa ja suorittaa sen. Tulostaa: Tämä on aliohjelma!
}

Katsotaan vielä tarkemmin parametreja, paluuarvoa ja aliohjelman kutsumista.

Parametrit ja paluuarvo. Aliohjelma voi ottaa vastaan tietoa parametreina, ja se voi palauttaa arvon. Alla oleva aliohjelma laskee kahden luvun summan ja palauttaa sen. Aliohjelma ottaa vastaan kaksi parametria ja palauttaa näiden parametrien arvojen summan.

public static int Summa(int a, int b)
{
    return a + b;
}

Kutsuminen. Aliohjelmaa kutsutaan kirjoittamalla aliohjelman nimi ja sulkujen sisään argumentit, joita haluamme antaa aliohjelmalle.

int summa = Summa(3, 5);
Console.WriteLine(summa); // Tulostaa 8

{: .terminologia } Aliohjelman kutsussa annettavia arvoja kutsutaan argumenteiksi. Argumenttien arvot välitetään aliohjelman parametreihin. Kirjallisuudessa saatetaan nimittää kumpiakin näistä asioista parametreiksi, mutta tässä käytämme edellä mainittuja termejä.

Jos aliohjelma määritetään void-tyyppiseksi, se ei palauta arvoa, ts. siinä ei ole return-lauseita.

public static void Tervehdys()
{
    Console.WriteLine("Moikka!");
}

Jos aliohjelman paluuarvon tyypiksi on määritelty jotain muuta kuin void, aliohjelmassa tulee olla vähintään yksi return-lause. Alla oleva koodi aiheuttaisi käännösvirheen.

public static int Summa(int a, int b)
{
    Console.WriteLine(a + b);
    // Käännösvirhe: "not all code paths return a value"
}

Osan kaikki tehtävät

Osa 4

Katso luennot 7 ja 8

Tässä osassa...

• toistorakenteet
• merkkijonot

➿ Toistorakenteet

Toistorakenteilla voidaan toistaa jonkin lauseen tai lauseiden suoritusta niin kauan kuin jokin ehto on voimassa. Toistorakenteita ovat while, do-while, for, ja foreach.

Tulostetaan luvut 1-10 käyttäen while-silmukkaa ja for-silmukkaa.

int i = 1;
while (i <= 10)
{
    Console.WriteLine(i);
    i++;
}

for (int i = 1; i <= 10; i++)
{
    Console.WriteLine(i);
}

For- ja while-silmukoilla voidaan periaatteessa tehdä ihan samat asiat. Tavallista on kuitenkin, että for-silmukkaa käytetään, kun tiedetään, kuinka monta kierrosta silmukkaa halutaan suorittaa. While-silmukkaa käytetään, kun silmukan suorituskertojen määrä ei ole tiedossa etukäteen.

For-silmukkaan kuuluu osat alustus (yllä int i = 1), toistoehto (i <= 10), päivitys (i++) ja runko-osa (aaltosulkeiden rajaama osa). Mikä tahansa näistä osista voi olla tyhjä, mutta puolipisteet on silti kirjoitettava. While-silmukassa on vain toistoehto ja runko-osa. Alustuksesta ja päivityksestä on huolehdittava itse.

Foreach-silmukkaa käytetään erityisesti kokoelmien, kuten listojen ja sanakirjojen kanssa. Foreach-silmukkaa käytetään erityisesti tilanteissa, kun halutaan käydä läpi kaikki taulukon tai kokoelman alkiot. Myöhemmillä kursseilla käydään myös läpi abstrakteja tietorakenteita, joissa foreach-silmukka on kätevä tai jopa ainoa tapa käydä läpi tietorakenteen alkiot.

int[] luvut = { 7, 3, 1, -5, 9};
foreach (int luku in luvut)
{
    Console.WriteLine(luku);
}

Huomaa erityisesti, että foreach-silmukassa ei ole erikseen alustus- ja päivityslauseita. Foreach-silmukka soveltuu hyvin tilanteisiin, joissa taulukon tai kokoelman alkiot halutaan käydä läpi ilman, että niiden indeksejä tarvitaan. Foreach-silmukkaa ei voi käyttää, jos taulukon tai kokoelman alkioita halutaan muuttaa.

Silmukoita voi kirjoittaa myös sisäkkäin.

for (int i = 1; i < 5; i++)
{
    for (int j = 2; j < 8; j++)
    {
        // Tulostetaan kaikki mahdolliset
        // i:n ja j:n muodostamien parien arvot
        Console.WriteLine($"{i}, {j}");
    }
}

Tarvittaessa break-lauseella voidaan lopettaa silmukka ja siirtyä silmukan jälkeiseen koodiin. Toisaalta continue-lauseella voidaan tarvittaessa päättää yksi silmukan kierros.

// Tulostetaan luvut 1, 2, 3, 4, 6, 7. Luku 5 jätetään välistä,
// ja luvun 8 kohdalla silmukka lopetetaan.
for (int i = 1; i <= 10; i++)
{
    if (i == 5)
    {
        continue; // Siirrytään seuraavaan kierrokseen
    }
    if (i == 8)
    {
        break; // Lopetetaan silmukan suoritus
    }
    Console.WriteLine(i);
}

Merkkijonot

String

Tehtävät

Tee TIMissä (linkki)

➕ Operaattorit

Ohjelmointikielissä operaattorit ovat erityisiä symboleja tai avainsanoja, jotka suorittavat tiettyjä operaatioita arvojen tai muuttujien välillä. Operaattoreita käytetään lausekkeissa, jotka muodostavat ohjelman logiikan ja toiminnallisuuden.

Aritmeettiset operaattorit

Aritmeettisia operaattoreita käytetään matemaattisten laskutoimitusten suorittamiseen.

• + yhteenlasku
• - vähennys
• * kertolasku
• / jakolasku
• % jäännös

Esimerkkejä:

int a = 10;
int b = 3;
int summa = a + b;        // summa on 13
int erotus = a - b;      // erotus on 7
int tulo = a * b;        // tulo on 30
int osamaara = a / b;    // osamaara on 3
int jaannos = a % b;     // jaannos on 1

Vertailu- ja loogiset operaattorit

Vertailuoperaattoreita käytetään arvojen vertaamiseen ja ne tuottavat totuusarvon (true tai false) perustuen vertailun tulokseen.

• == on yhtä suuri kuin
• != ei ole yhtä suuri kuin
• < pienempi kuin
• > suurempi kuin
• <= pienempi tai yhtä suuri kuin
• >= suurempi tai yhtä suuri kuin

Esimerkkejä:

int x = 5;
int y = 10;
bool onkoYhtasuuri = x == y;  // false
bool onkoEri = x != y;        // true
bool onkoPienempi = x < y;    // true
bool onkoSuurempi = x > y;    // false

Loogiset operaattorit

Loogisia operaattoreita käytetään totuusarvojen käsittelyyn

• && JA, on tosi, jos kumpikin arvoista on tosi
• || TAI, on tosi, jos ainakin toinen arvoista on tosi
• ! EI, kääntää totuusarvon (tosi -> epätosi, epätosi -> tosi)

Esimerkkejä:

int a = 5;
int b = 3;
bool totuus1 = a > b;   // true
bool totuus2 = b == 67;  // false
bool tulos1 = totuus1 && totuus2;  // false
bool tulos2 = totuus1 || totuus2;  // true
bool tulos3 = !totuus1;      // false

Sijoitusoperaattorit

Näitä käytetään arvojen asettamiseen muuttujille.

• = sijoitus
• += lisää ja sijoita
• -= vähennä ja sijoita
• *= kerro ja sijoita
• /= jaa ja sijoita
• %= jäännös ja sijoita
• ++ lisää yhdellä
• -- vähennä yhdellä

Lisäys- ja vähennysoperaattorit ++ ja -- voidaan kirjoittaa joko ennen tai jälkeen muuttujan nimen. Jos operaattori on ennen muuttujaa (esim. ++x), sitä kutsutaan etuliitteeksi (engl. prefix), ja jos se on muuttujan jälkeen (esim. x++), sitä kutsutaan jälkiliitteeksi (engl. postfix). Ero näiden välillä tulee esiin erityisesti, kun operaattoria käytetään osana suurempaa lauseketta.

Esimerkkejä:

int luku = 10;     // luku on nyt 10
luku += 5;        // luku on nyt 15 (10 + 5)
luku -= 3;        // luku on nyt 12 (15 - 3)
luku *= 2;        // luku on nyt 24 (12 * 2)
luku /= 4;        // luku on nyt 6 (24 / 4)
luku %= 4;        // luku on nyt 2 (6 % 4)

luku++;           // luku on nyt 3
System.Console.WriteLine(luku); // tulostaa 3
System.Console.WriteLine(luku++); // tulostaa 3, sitten luku on nyt 4
System.Console.WriteLine(++luku); // luku on nyt 5, sitten tulostaa 5

↔️ Ehtolauseet

Ehtolauseet ovat rakenteita, jotka suorittavat tiettyjä lauseita vain, jos jokin ehto on voimassa. Ehtolauseella voidaan ikään kuin hypätä sellaisen koodin yli, jota ei ole tarpeellista suorittaa.

Ehtolauseita ovat if sekä switch-case. if-ehtolause voidaan tarvittaessa jakaa useampaan osaan else if ja else-osilla. Rakennetta voidaan havainnollistaa seuraavalla kuvalla.

Koodissa tämä näyttäisi suurin piirtein seuraavalta.

if (EHTO)
{
    // Suoritetaan, jos ehto on voimassa
}

Yllä olevassa esimerkissä EHTO-sanan kohdalle kirjoitetaan jokin totuusarvon tuottava lauseke.

Totuusarvoja voidaan tuottaa esimerkiksi vertailuoperaattoreilla. Alla muutama esimerkki

==   on yhtä kuin
!=   on eri kuin
<    on pienempi kuin
>    on suurempi kuin
<=   on pienempi tai yhtä suuri kuin
>=   on suurempi tai yhtä suuri kuin

Vertailuoperaattori vertailee kahta arvoa ja tuottaa true- tai false-arvon.

int a = 5;
int b = 3;
if (a > b)
{
    Console.WriteLine("a on suurempi kuin b");
}

Ehtolauseita voidaan ketjuttaa tarvittaessa.

Yllä oleva kuva koodina olisi suurin piirtein seuraavanlaista.

if (EHTO1)
{
    // Suoritetaan, jos ehto1 on voimassa
    // LAUSE
}
else if (EHTO2)
{
    // Suoritetaan, jos ehto2 on voimassa
    // ...
}
else 
{
    // Suoritetaan, jos mikään ehto ei ole voimassa
    // ...
}

Vertailuja voidaan yhdistellä loogisilla operaattoreilla, kuten && (ja), || (tai) ja ! (ei).

int luku = 5;
if (luku > 0 && luku < 10)
{
    Console.WriteLine("Luku on välillä 0-10");
}

Switch-case

Switch-case-rakenne on myös ehtolauserakenne. Sen avulla voidaan vertailla muuttujan arvoa if-else-lauseiden tavoin, mutta joissain tilanteissa hieman vähemmällä kirjoittamisella.

int luku = 47;
switch (luku)
{
   case < 50:
      Console.WriteLine("Luku on pienempi kuin 50");
      break;
   case > 50:
      Console.WriteLine("Luku on suurempi kuin 50");
      break;
   default:
      Console.WriteLine("Luku on 50");
      break;
}

Osan kaikki tehtävät

Osa 5

Katso luennot 9 ja 10

Tässä osassa...

• toistorakenteet, osa 2
• taulukot
• debuggaus

Toistorakenteet, osa 2

Taulukot

Debuggaus

Tehtävät

Debuggaus

Tässä esitellään lyhyesti debuggauksen tarkoitus ja Riderin tärkeimmät debuggaustoiminnot. Vaikka jokaisessa kehitysympäristössä on omat debuggaustapansa, ovat periaatteet hyvin pitkälti yhteisiä eri ympäristöjen välillä.

Tämä sivu kuuluu myös Ohjelmointi 1 -kurssin debuggausnäytteen esitietoihin. Lue tämä sivu huolellisesti ennen debuggausnäytteeseen tulemista.

Miksi pitää debugata?

Jos ohjelmassa on jotakin vikaa (ohjelmointivirhe eli bug), debuggeri on usein helpoin vaihtoehto vian löytämiseksi (virheenjäljitys eli debug). Ohjelmaa voi debugata myös lisäämällä sinne tänne ylimääräisiä tulostuslauseita, mutta debuggerin avulla ohjelmakoodiin ei tarvitse tehdä muutoksia. Debuggerin avulla ohjelma voidaan myös pysäyttää haluttuun kohtaan ja tutkia muuttujien senhetkisiä arvoja, mahdollisesti jopa muuttaa niitä ennen kuin ohjelman suorittamista taas jatketaan. Tämä ei ole mahdollista tulostuslause-tyylisessä debuggauksessa.

Ohjelmointia opetellessa debuggeri on myös oiva väline askeltaa silmukoita, ehtoja ja aliohjelmia ja näin havainnollistaa ohjelman kulkua itselleen.

Debuggaustila Riderissa

Debuggaustila käynnistetään painamalla Run → Debug tai leppäkertun kuvaa. Tällöin ohjelma voidaan pysäyttää ns. keskeytyskohtien avulla ja tutkia ohjelman tilaa. Jos ohjelmassa ei ole yhtään keskeytyskohtaa, vaikuttaa debugtilassa ajo samanlaiselta kuin "normaalissa" suoritustilassa.

Jos ohjelma tuntuu olevan totaalisen jumissa, voidaan sen ajo pysäyttää ja katsoa, missä kohti ohjelmaa ollaan menossa ja näin ehkä voidaan ratkaista, mistä ohjelman jumi johtuu.

Rider työkalupalkki:

Kannattaa harjoitella käyttämään näppäinoikoteitä debuggaustilassa, sillä ne nopeuttavat debuggausta huomattavasti. Riderin näppäinoikoteitä saa tarkistettua ja muutettua Configure -> Settings -> Keymap tai File -> Settings -> Keymap.

Keskeytyskohta (breakpoint)

Voit laittaa ohjelmaan keskeytyskohdan (engl. breakpoint), jonka tarkoituksena on keskeyttää ohjelman suoritus haluttuun kohtaan. Toisin sanoen, ohjelma suoritetaan alusta siihen saakka, kunnes tullaan keskeytyskohtaan, johon suoritus sitten pysähtyy.

Riderissa keskeytyskohta asetetaan klikkaamalla sitä rivinumeroa, johon keskeytyskohta halutaan asettaa. Keskeytyskohtaa EI voi asettaa Riderissä tyhjälle riville, kommenttiriveille eikä funktion tai luokan esittelyriville.

Keskeytyskohtia voi olla ohjelmassa useita. Keskeytyskohdan saa pois klikkaamalla sitä uudestaan.

Debuggaustilan käynnistäminen

Ohjelma käynnistyy debuggaustilaan painamalla joko F5, klikkaamalla oikean ylälaidassa olevaa Debug painiketta tai valitsemalla valikosta Run -> Debug. Tällöin ohjelman suoritus "pysähtyy" ensimmäiseen asettamaasi keskeytyskohtaan.

Huomaa, että keskeytyskohdan osoittaman punaisen pallon vieressä on nyt myös keltainen nuoli, joka näyttää seuraavaksi suoritettavan rivin. Toisin sanoen, ohjelman alkuosa on suoritettu rivi riviltä normaaliin tapaan, ja suoritus pysähtyy keskeytyskohtaan siten, että seuraavaksi suoritusvuorossa on tutkittava rivi, jolle keskeytyskohta on asetettu. Korostan: tätä keltaisen nuolen osoittamaa asiaa ei ole vielä suoritettu.

On mahdollista suorittaa ohjelma myös ilman debuggausta (Ctrl + F5 tai valitsemalla Run). Tällöin keskeytyskohdat jätetään huomiotta. Toisaalta silloin myös esimerkiksi mahdollisia poikkeuksia ei käsitellä Riderin avulla.

Askellus (Step into, Step over)

Koodia voidaan askeltaa rivi kerrallaan. Tällöin ohjelman suoritus etenee debuggaustilassa lause kerrallaan eteenpäin. Askellukseen on kaksi erilaista tapaa

• Step into (F11), jos lause on aliohjelmakutsu, askelletaan myös kyseisen aliohjelman koodi
• Step over (F10), aliohjelmakutsujen koodi suoritetaan kerralla ilman askellusta, eli tavallaan hypätään aliohjelman yli

Step over -toimintoa kannattaa käyttää sellaisen aliohjelmakutsun kohdalla, jonka sisäistä logiikka ei ole tarkoitus tarkastella. Esimerkiksi Console.WriteLine- aliohjelmakutsun kohdalla kannattaa mieluummin valita Step over kuin Step into, sillä meitä ei oikeastaan kiinnosta tuon aliohjelman toiminta.

Resume

Resume-toiminto jatkaa ohjelman suorittamista normaaliin tapaan. Mikäli ohjelmassa on myöhemmin keskeytyskohta, ohjelman suoritus keskeytyy siihen.

Debuggaustilan lopettaminen (ohjelman ajon lopettaminen)

Debuggauksen voi lopettaa painamalla Shift + F5 tai valikosta Run -> Stop debugging.

Muuttuja-arvot (locals)

Debuggaus‐näkymän Threads & Variables-paneelissa (tai välilehdellä) näkyy tällä hetkellä näkyvissä olevat muuttujat ja niiden arvot.

Locals-paneelissa voi myös muokata muuttujien arvoja ajonaikaisesti. Esimerkiksi muuttujan "luku"-arvoa voi muokata kaksoisklikkaamalla Value-sarakkeen kohdalta numeroa ja kirjoittamalla uuden luvun vanhan tilalle. Tämän jälkeen kannattaa painaa Enteriä, jotta editori ottaa muutoksen. Riderissa muuttujan arvoa voi locals-ikkunassa muokata painamalla F2 tai klikkaamalla hiiren oikealla ja valistemalla Set Value.

Huomautus double-tyyppisen arvon muuttamisesta: Double-tyyppisen muuttujan arvoa muutettaessa on arvoksi asetettava desimaaliluku, esimerkiksi 3.0. Mikäli asetat arvoksi kokonaisluvun, esimerkiksi 3, debuggeri antaa virheilmoituksen "Error: Size of source and of dest differ".

Watch

Paikallisten muuttujien lisäksi voidaan suorituksen aikana seurata itse valittuja muuttujia Add to Watches toiminnolla. Yksittäisten muuttujien lisäksi voidaan tarkastella lausekkeita, esimerkiksi taulukko[i] > suurin (tuottaisi true tai false).

1. Aseta keskeytyskohta haluamaasi paikkaan ja aloita debuggaus.
2. Etsi koodista se muuttuja (tai lauseke), jonka tilaa haluat tarkkailla ajon aikana. Valitse se (maalaamalla esimerkiksi hiirellä), klikkaa sitten hiiren oikealla ja valitse Add to Watches. Alla olevassa kuvassa lisätään suurin-muuttuja locals/watch-paneeliin.

3. Voit lisätä eri "watcheja" haluamasi määrän. Alla lisätään myös i, taulukko[i] ja taulukko[i] > suurin watch-paneeliin.

Huomaa, että watch-paneeliin lisäämäsi muuttuja (tai lauseke) ei välttämättä ole olemassa (ts. ei ole luotu tai ei "näy" sillä hetkellä), joten luonnollisestikaan tilaa ei voida tällöin tutkia. Alla olevassa kuvassa suoritus on menossa vasta rivillä 10.

Tässä esimerkissä i, taulukko[i] ja taulukko[i] > suurin ovat paikallisia muuttujia (lausekkeita) EtsiSuurin-lohkossa ja tulevat näkyviin kun ohjelman suoritus etenee sinne saakka.

Nyt watch-ikkunasta on helppo tarkastella esimerkiksi taulukon arvoja sitä mukaa kun silmukka etenee.

Muuttujan arvon muuttaminen

Tarvittaessa muuttujan arvoa voi muuttaa esim Locals-ikkunassa klikkaamalla arvoa ja sitten antamalla sille uuden arvon.

Ehdollinen keskeytyskohta

Debuggerin avulla voidaan lisätä myös keskeytyskohdalle keskeytymisen ehto. Tällaista keskeytyskohtaa kutsutaan nimellä ehdollinen keskeytyskohta. Sen avulla debuggeri keskeyttää ohjelman suorittamisen vain, kun keskeytyskohtaan annettu ehto toteutuu. Ehto voi olla mikä tahansa totuusarvoinen lauseke, esimerkiksi muuttujan tietty arvo.

Ehdollinen keskeytyskohta on kätevä esimerkiksi tilanteessa, jossa on pitkä silmukka, joka halutaan pysäyttää vain jossain tietyssä kohdassa. Jos ohjelma pysähtyisi silmukan jokaisella kierroksella, olisi hyvin työlästä ajaa ohjelmaa haluttuun pisteeseen. Ehdon voi lisätä seuraavasti:

1. Siirry haluamallesi riville koodissa

2. Siirry rivinumeron koodiin väliin ja klikkaa siihen breakpoint (näkyy punaisena täplänä)

3. Paina breakpointin kohdalla hiiren oikeaa näppäintä saadaksesi esiin valikon

4. Lisää Condition tekstikenttään lauseke, joka saa ajon aikana arvon true tai false, esimerkiksi

   luku == 4
   

   Sen sijaan

   int luku = 4 
   

   ei ole ehto, eikä kenttään voi myöskään laittaa if-sanaa. Kun lauseke saa arvon true debuggeri keskeyttää ohjelman suorittamisen. Muutamia muita esimerkkejä ehdoista:

   i > 3
   luvut[i+2] != 3
   pallot[i] == null
   

5. Aloita debuggaus

6. Kun pysähtyy, tarkastele Locals- ja Watch-ikkunoista muuttujien arvoja ja jatka tarvittaessa Step into, Step over tai Resume.

Hit Count

Hit Countilla voit laittaa ehdon niin, että kun näin monennen kerran tullaan keskeytyskohtaan, niin silloin pysähdytään.

Kutsupino (call stack)

Jos saa ison ohjelman tutkittavakseen ja pitää korjata jotakin kohtaa eikä tiedä mistä kyseiseen kohtaan tullaan, niin jälleen debuggeri on avuksi. Laita keskeytyskohta tutkittavaan kohtaan, sitten ohjelma käyntiin. Kun ohjelma pysähtyy laittamaasi keskeytyskohtaan, niin kutsupinosta (call stack) voidaan katsoa reitti, mistä pysäytyskohtaan on päädytty.

Jos kutsupinoa ei näy Debug-näkymässä, sen saa esille valitsemalla klikkaamalla paneelin oikeassa yläreunassa olevaa ikkunan näköistä kuvaketta: Layout settings -> Threads Frames -> Side by side.

Riderin kutsupinossa ei valitettavasti näy lähdekoodin rivinumeroita siitä, miltä riviltä kutsuun on lähdetty. Mutta klikkaamalla kutsupinossa hiiren oikealla, voidaan ottaa pinon sisältä leikepöydälle ja sitten tarkastella sitä rivinumeroineen jossakin editorissa.

Ongelmia debuggaustilan käynnistymisessä?

class com.intellij.util.ui.components cannot be cast

Mikäli saat debuggauksen aikana Riderissa poikkeuksen, esim.

class com.intellij.util.ui.components.BorderLayoutPanel 
cannot be cast to class com.intellij.ui.OnePixelSplitter

kokeile asetusten resetointia seuraavien ohjeiden mukaisesti

HUOM! Näin tekemällä menetät kaikki asetuksesi, kuten näppäinoikotiet sekä teemat. Ota asetuksistasi halutessasi varmuuskopiot File -> Manage IDE Settings -> Export Settings.

• Paina Shift+Shift (eli kaksi kertaa Shift-painiketta) tai Ctrl+T,
• kirjoita Restore Default settings ja valitse ko. toiminto
• Rider käynnistyy uudestaan, valitse haluamasi asetukset.

Rider clr load callback is already in error state. A debug component is not installed

Jos saat yllä mainitun virheilmoituksen kun yrität käynnistää debuggerin niin ongelmana on todennäköisesti, että Mac-koneelle on asennettu väärä versio Riderista.

Joudut siis asentamaan Riderin uudestaan:

• Mene sivulle: https://www.jetbrains.com/rider/
• Klikkaa Download
• Valitse omalle koneellesi sopiva versio ja lataa se
• Asenna Rider uudelleen

Osan kaikki tehtävät

Osa 6

Katso luennot 11 ja 12

Tässä osassa...

• taulukoita ja silmukoita lisää
• tyyppimuunnokset

Taulukoita ja silmukoita lisää

Tyyppimuunnokset

Tehtävät

Osan kaikki tehtävät

Osa 7

Katso luennot 13 ja 14

Tässä osassa...

• moniulotteiset taulukot
• listat
• muokattavat merkkijonot

Moniulotteiset taulukot

Listat

Muokattavat merkkijonot

Tehtävät

Osan kaikki tehtävät

Osa 8

Katso luennot 15 ja 16.

Tässä osassa...

• C#-kielen tyyppijärjestelmä
• näkyvyysalueet ja nimiavaruudet
• rekursio

C#-kielen tyyppijärjestelmä

Alkeistietotyypit

Näkyvyysalueet ja nimiavaruudet

Rekursio

Tehtävät

Osan kaikki tehtävät

Osa 9

Tässä osassa...

• poikkeukset
• tiedostojen käsittely

Poikkeukset

Tiedostojen käsittely

Osa 10

Tässä osassa...

• ?

?

Osan kaikki tehtävät

Osa 11

Katso yhteenveto-luento

Tässä osassa...

• kertaus

Kertaus

Tässä osassa kerrataan aiemmin opittuja asioita.

Kertaus

Osan kaikki tehtävät

Omat tiedot

Linkit timiin

Omat tiedot TIMissä.