Øvelse – kall opp metodene for en .NET-klasse

12 minutter

Enten du innså det eller ikke, har du ringt C#-metoder helt siden ditt første «Hello, World!»-program. Dette programmet bruker WriteLine() klassens metode Console til å vise meldingen «Hallo, verden!».

Men ikke alle klasser og metoder implementeres på samme måte. Denne enheten dekker noen av de vanligste variantene du må forstå når du bruker metoder fra .NET-klassebiblioteket. Enda viktigere er det at du lærer hvordan du finner og bruker dokumentasjonen for å bedre forstå mer om hver metode.

Slik kaller du opp metoder i .NET-klassebiblioteket

Fra din tidligere erfaring med Console.WriteLine() metoden, bør du allerede vite det grunnleggende:

Begynn med å skrive inn klassenavnet. I dette tilfellet er Consoleklassenavnet .
Legg til medlemstilgangsoperatoren, symbolet . .
Legg til navnet på metoden. I dette tilfellet er WriteLinemetodens navn .
Legg til operatoren for metodeaktivering, som er et sett med parenteser ().
Til slutt angir du argumentene som sendes til metoden, hvis det er noen, mellom parentesene til metodens aktiveringsoperator. I dette tilfellet angir du teksten du vil at metoden skal Console.WriteLine() skrive til konsollen (for eksempel "Hello World!").

Avhengig av hvordan utviklerne utformet og implementerte den angitte metoden, må du kanskje også:

Send flere verdier som inndataparametere.
Godta en returverdi.

I den neste enheten skal du undersøke hvordan du sender inndataverdier til en metode, og hvordan en metode kan brukes til å returnere en verdi til kallrutinen.

Selv om noen metoder kan kalles på samme måte som du kalte Console.WriteLine(), finnes det andre metoder i .NET-klassebiblioteket som krever en annen fremgangsmåte.

Klargjøre kodemiljøet

Denne modulen inneholder kodeaktiviteter som veileder deg gjennom prosessen med å bygge og kjøre eksempelkode. Du oppfordres til å fullføre disse aktivitetene ved hjelp av Visual Studio Code som utviklingsmiljø. Hvis du bruker Visual Studio Code for disse aktivitetene, kan du bli mer komfortabel med å skrive og kjøre kode i et utviklermiljø som brukes av profesjonelle over hele verden.

Åpne Visual Studio Code.

Du kan bruke Start-menyen i Windows (eller tilsvarende ressurs for et annet operativsystem) til å åpne Visual Studio Code.
Velg Åpne mappe på Visual Studio Code File-menyen.
Gå til Windows-skrivebordsmappen i dialogboksen Åpne mappe .

Hvis du har en annen mappeplassering der du beholder kodeprosjekter, kan du bruke denne mappeplasseringen i stedet. For denne opplæringen er det viktig å ha en plassering som er enkel å finne og huske.
Velg Velg mappe i dialogboksen Åpne mappe.

Hvis du ser en sikkerhetsdialogboks som spør om du stoler på forfatterne, velger du Ja.
Velg Ny terminal på Visual Studio Code Terminal-menyen.

Legg merke til at en ledetekst i Terminal-panelet viser mappebanen for gjeldende mappe. Eksempel:
```
C:\Users\someuser\Desktop>
```
Merk deg

Hvis du arbeider på din egen PC i stedet for i en sandkasse eller et vertsbasert miljø, og du har fullført andre Microsoft Learn-moduler i denne C#-serien, har du kanskje allerede opprettet en prosjektmappe for kodeeksempler. Hvis dette er tilfellet, kan du hoppe over neste trinn, som brukes til å opprette en konsollapp i TestProject-mappen.
Hvis du vil opprette et nytt konsollprogram i en angitt mappe i terminalkommandoen, skriver du inn følgende ledetekst:
```
dotnet new console -o ./CsharpProjects/TestProject
```
Denne .NET CLI-kommandoen bruker en .NET-programmal til å opprette et nytt C#-konsollprogramprosjekt i den angitte mappeplasseringen. Kommandoen oppretter mappene CsharpProjects og TestProject for deg, og bruker TestProject som navnet på .csproj filen.

Hvis det vises en melding som forteller deg at filene allerede finnes, fortsetter du med de neste trinnene. Du bruker de eksisterende prosjektfilene på nytt.
Utvid CsharpProjects-mappen i EXPLORER-visningen.

Du skal se TestProject-mappen og to filer, en C#-programfil med navnet Program.cs og en C#-prosjektfil kalt TestProject.csproj.
Velg Åpne mappe på Visual Studio Code File-menyen.
Velg CsharpProjects-mappen i dialogboksen Åpne mappe, og velg deretter Velg mappe.
Utvid TestProject-mappen i UTFORSKER-visningen, og velg deretter Program.cs.
Slett eksisterende kodelinjer.

Du skal bruke dette C#-konsollprosjektet til å opprette, bygge og kjøre kodeeksempler under denne modulen.
Lukk Terminal-panelet.

Kall opp ulike typer metoder i .NET-klassebiblioteket

Hvis du vil opprette et kodeeksempel i Visual Studio Code Editor som implementerer metoder System.Random for klassene og System.Console klassene, skriver du inn følgende kode:
```
Random dice = new Random();
int roll = dice.Next(1, 7);
Console.WriteLine(roll);
```
Denne koden simulerer et terningkast ved hjelp av Random.Next() metoden for å generere et tall, og Console.WriteLine() metoden for å vise verdien.

Merk deg

Du vil undersøke koden i detalj senere i denne enheten.
Klikk Lagre på Visual Studio Code File-menyen.
Hvis du vil åpne en terminal i TestProject-mappeplasseringen i UTFORSKER-visningen, høyreklikker du TestProject, og deretter velger du Åpne i integrert terminal.

Legg merke til at Terminal-panelet inneholder en ledetekst som viser en mappebane. Eksempel:
```
C:\Users\someuser\Desktop\CsharpProjects\TestProject>
```
Når du bruker Terminal til å kjøre .NET CLI-kommandoer, kjører kommandoer fra den viste mappeplasseringen. Kontroller at kodemappen samsvarer med mappebanen som vises i ledeteksten før du bygger eller kjører koden.
Skriv inn dotnet-kjøring i terminalkommandoledeteksten for å kjøre koden, og trykk deretter ENTER.

Legg merke til at et tall fra 1 til 6 vises i konsollutgangen (antall prikker på terningene). Hvis du kjører koden nok ganger, vil du se hvert av tallene 1-6 vist.
Ta et minutt å undersøke syntaksen som brukes til å få tilgang til metodene Next() og WriteLine() .

Legg merke til at du bruker forskjellige teknikker for å få tilgang til metodene.
```
Random dice = new Random();
int roll = dice.Next(1, 7);
Console.WriteLine(roll);
```
På den tredje kodelinjen inkluderer du en referanse til Console klassen og kaller Console.WriteLine() metoden direkte. Du bruker imidlertid en annen teknikk for å kalle Random.Next() metoden. Grunnen til at du bruker to ulike teknikker er fordi noen metoder er "stateful" og andre er "stateless". Du undersøker forskjellen mellom tilstandsfulle og statsløse metoder i neste del.

Stateful versus stateless metoder

I prosjekter for programvareutvikling brukes termtilstanden til å beskrive tilstanden til utførelsesmiljøet på et bestemt tidspunkt. Når koden kjører linje for linje, lagres verdiene i variabler. Når som helst under kjøringen, er gjeldende tilstand for programmet samlingen av alle verdier som er lagret i minnet.

Noen metoder er ikke avhengige av gjeldende tilstand for programmet for å fungere som den skal. Med andre ord implementeres tilstandsløse metoder slik at de kan arbeide uten å referere til eller endre verdier som allerede er lagret i minnet. Tilstandsløse metoder kalles også statiske metoder.

Metoden er for eksempel Console.WriteLine() ikke avhengig av verdier som er lagret i minnet. Den utfører sin funksjon og avsluttes uten å påvirke tilstanden til programmet på noen måte.

Andre metoder må imidlertid ha tilgang til tilstanden til programmet for å fungere som den skal. Med andre ord er tilstandsfulle metoder bygget på en slik måte at de er avhengige av verdier som er lagret i minnet av tidligere kodelinjer som allerede er utført. Eller de endrer tilstanden til programmet ved å oppdatere verdier eller lagre nye verdier i minnet. De kalles også forekomstmetoder.

Tilstandsfulle metoder (forekomst) holder oversikt over tilstanden i felt, som er variabler som er definert i klassen. Hver nye forekomst av klassen får sin egen kopi av de feltene der tilstanden lagres.

Én enkelt klasse kan støtte både tilstandsfulle og statsløse metoder. Men når du må kalle tilstandsfulle metoder, må du først opprette en forekomst av klassen slik at metoden kan få tilgang til tilstand.

Opprette en forekomst av en klasse

En forekomst av en klasse kalles et objekt. Hvis du vil opprette en ny forekomst av en klasse, bruker du operatoren new . Vurder følgende kodelinje som oppretter en ny forekomst av Random klassen for å opprette et nytt objekt kalt dice:

Random dice = new Random();

Operatoren new gjør flere viktige ting:

Den ber først om en adresse i datamaskinens minne som er stor nok til å lagre et nytt objekt basert på Random klassen.
Det oppretter det nye objektet, og lagrer det på minneadressen.
Den returnerer minneadressen slik at den dice kan lagres i objektet.

Fra da av dice , når objektet refereres til i kode, utfører .NET Runtime et oppslag bak kulissene for å gi en illusjon om at du arbeider direkte med selve objektet.

Koden bruker dice objektet som en variabel som lagrer tilstanden til Random klassen. Når du kaller Next() opp metoden på dice objektet, bruker metoden tilstanden som er lagret i dice objektet, til å generere et tilfeldig tall.

Den nyeste versjonen av .NET Runtime gjør det mulig å starte et objekt uten å måtte gjenta typenavnet (aktivering av målskrevet konstruktør). Følgende kode oppretter for eksempel en ny forekomst av Random klassen:

Random dice = new();

Hensikten er å forenkle lesbarheten av kode. Du bruker alltid parenteser når du skriver et uttrykk med måltype new .

Hvorfor er Neste()-metoden tilstandsfull?

Du lurer kanskje på hvorfor Next() metoden ble implementert som en staselig metode? Kan ikke .NET-klassebibliotekutformerne finne ut en måte å generere et tilfeldig tall på uten å kreve tilstand? Og hva blir lagret eller referert til av Next() metoden?

Dette er rettferdige spørsmål. På et høyt nivå er datamaskiner flinke til å følge spesifikke instruksjoner for å opprette et pålitelig og repeterbart resultat. For å skape en illusjon av tilfeldighet, bestemte utviklerne av Next() metoden seg for å fange datoen og klokkeslettet ned til brøkdelen av et millisekund og bruke det til å så en algoritme som produserer et annet tall hver gang. Selv om det ikke er helt tilfeldig, er det nok for de fleste programmer. Tilstanden som fanges opp og opprettholdes gjennom objektets levetid dice , er frøverdien. Hvert etterfølgende kall til Next() metoden kjører algoritmen på nytt, men sikrer at frøet endres slik at den samme verdien ikke (nødvendigvis) returneres.

Hvis du vil bruke Random.Next() metoden, trenger du imidlertid ikke å forstå hvordan det fungerer. Det viktigste å vite er at noen metoder krever at du oppretter en forekomst av en klasse før du ringer dem, mens andre ikke gjør det.

Hvordan kan du avgjøre om du trenger å opprette en forekomst av en klasse før du kaller metodene?

Én fremgangsmåte for å avgjøre om en metode er tilstandsløs eller statsløs, er å se dokumentasjonen. Dokumentasjonen inneholder eksempler som viser om metoden må kalles fra objektforekomsten eller direkte fra klassen.

Merk deg

Du må kanskje rulle nedover på dokumentasjonssiden for å finne kodeeksempler.

Som et alternativ til å søke gjennom produktdokumentasjon, kan du prøve å få tilgang til metoden direkte fra selve klassen. Hvis det fungerer, vet du at det er en tilstandsløs metode. Det verste som kan skje, er at du får en kompileringsfeil.

Prøv å få Random.Next() tilgang til metoden direkte, og se hva som skjer.

Skriv inn følgende kodelinje i Visual Studio Code Editor:
```
int result = Random.Next();
```
Du vet allerede at det Next() er en tilstandsfull metode, men dette eksemplet viser hvordan Visual Studio Code Editor reagerer når du prøver å få feil tilgang til en metode.
Legg merke til at en rød bølgete linje vises under Random.Next, noe som angir at du har en kompileringsfeil.

Hvis metoden du er interessert i å bruke, er tilstandsløs, vises ingen rød bølgete linje.
Hold musepekeren over den røde bølgete linjen.

Et popup-vindu skal vises med følgende melding:
```
(1,14): error CS0120: An object reference is required for the non-static field, method, or property 'Random.Next()'
```
Som du så i koden i begynnelsen av enheten, kan du løse denne feilen ved å opprette en forekomst av Random klassen før du får Next() tilgang til metoden. Eksempel:
```
Random dice = new Random();
int roll = dice.Next();
```
I dette tilfellet Next() kalles metoden uten inndataparametere.

Sammendrag

Hvis du vil kalle opp metoder for en klasse i .NET-klassebiblioteket, bruker du formatet ClassName.MethodName(), der symbolet . er medlemstilgangsoperatoren for å få tilgang til en metode som er definert i klassen, og () symbolene er metodens aktiveringsoperatorer.
Når du kaller en tilstandsløs metode, trenger du ikke å opprette en ny forekomst av klassen først.
Når du kaller opp en tilstandsfull metode, må du opprette en forekomst av klassen og få tilgang til metoden på objektet.
Bruk operatoren new til å opprette en ny forekomst av en klasse.
En forekomst av en klasse kalles et objekt.