Övning – Anropa metoderna för en .NET-klass

12 minuter

Oavsett om du har insett det eller inte har du anropat C#-metoder ända sedan ditt första "Hello, World!"-program. Det programmet använder WriteLine() -metoden för Console klassen för att visa meddelandet "Hello, World!".

Alla klasser och metoder implementeras dock inte på samma sätt. Den här lektionen beskriver några av de vanligaste varianterna som du behöver förstå när du använder metoder från .NET-klassbiblioteket. Dessutom får du lära dig hur du letar rätt på och använder dokumentation som gör att du förstår metoden bättre.

Anropa metoder i .NET-klassbiblioteket

Din erfarenhet av metoden Console.WriteLine() gör att du redan känner till grunderna:

Börja med att skriva klassnamnet. I det här fallet är Consoleklassnamnet .
Lägg till medlemsåtkomstoperatorn, symbolen . .
Lägg till metodens namn. I det här fallet är WriteLinemetodens namn .
Lägg till metodanropsoperatorn, som är en uppsättning parenteser ().
Ange slutligen de argument som skickas till metoden, om det finns några, mellan parenteserna för metodens anropsoperator. I det här fallet anger du den text som du vill Console.WriteLine() att metoden ska skriva till konsolen (till exempel "Hello World!").

Beroende på hur utvecklaren har utformat och implementerat metoden kan du även behöva göra följande:

Skicka ytterligare värden som indataparametrar.
Acceptera ett returvärde.

I nästa lektion ska du undersöka hur du skickar indatavärden till en metod och hur en metod kan användas för att returnera ett värde till anropsrutinen.

Vissa metoder kan kallas på samma sätt som du kallade Console.WriteLine(), men det finns andra metoder i .NET-klassbiblioteket som kräver en annan metod.

Förbereda din kodningsmiljö

Den här modulen innehåller kodningsaktiviteter som vägleder dig genom processen att skapa och köra exempelkod. Du uppmanas att slutföra dessa aktiviteter med Visual Studio Code som utvecklingsmiljö. Genom att använda Visual Studio Code för dessa aktiviteter kan du bli mer bekväm med att skriva och köra kod i en utvecklarmiljö som används av proffs över hela världen.

Öppna Visual Studio Code.

Du kan använda Windows Start-menyn (eller motsvarande resurs för ett annat operativsystem) för att öppna Visual Studio Code.
På menyn Visual Studio Code-fil väljer du Öppna mapp.
I dialogrutan Öppna mapp navigerar du till mappen Windows Desktop.

Om du har en annan mappplats där du behåller kodprojekt kan du använda den mappplatsen i stället. För den här utbildningen är det viktigt att ha en plats som är lätt att hitta och komma ihåg.
I dialogrutan Öppna mapp väljer du Välj mapp.

Om du ser en säkerhetsdialogruta som frågar om du litar på författarna väljer du Ja.
Välj Ny terminal på visual Studio Code-terminalmenyn.

Observera att en kommandotolk i terminalpanelen visar mappsökvägen för den aktuella mappen. Till exempel:
```
C:\Users\someuser\Desktop>
```
Anmärkning

Om du arbetar på din egen dator i stället för i en sandbox-miljö eller en värdbaserad miljö och du har slutfört andra Microsoft Learn-moduler i den här C#-serien kanske du redan har skapat en projektmapp för kodexempel. I så fall kan du hoppa över nästa steg, som används för att skapa en konsolapp i mappen TestProject.
I terminalkommandot anger du följande fråga för att skapa ett nytt konsolprogram i en angiven mapp:
```
dotnet new console -o ./CsharpProjects/TestProject
```
Det här .NET CLI-kommandot använder en .NET-programmall för att skapa ett nytt C#-konsolprogramprojekt på den angivna mappplatsen. Kommandot skapar mapparna CsharpProjects och TestProject åt dig och använder TestProject som namnet på filen .csproj .

Om ett meddelande visas som talar om för dig att filerna redan finns fortsätter du med nästa steg. Du återanvänder de befintliga projektfilerna.
I utforskarvyn expanderar du mappen CsharpProjects .

Du bör se mappen TestProject och två filer, en C#-programfil med namnet Program.cs och en C#-projektfil med namnet TestProject.csproj.
På menyn Visual Studio Code-fil väljer du Öppna mapp.
I dialogrutan Öppna mapp väljer du mappen CsharpProjects och väljer sedan Välj mapp.
I explorer-vyn expanderar du mappen TestProject och väljer sedan Program.cs.
Ta bort de befintliga kodraderna.

Du kommer att använda det här C#-konsolprojektet för att skapa, skapa och köra kodexempel under den här modulen.
Stäng terminalpanelen.

Anropa olika typer av metoder i .NET-klassbiblioteket

I Visual Studio Code-redigeraren anger du följande kod för att skapa ett kodexempel som implementerar metoder System.Random för klasserna och System.Console :
```
Random dice = new Random();
int roll = dice.Next(1, 7);
Console.WriteLine(roll);
```
Den här koden simulerar en tärningskast med hjälp av Random.Next() metoden för att generera ett tal och Console.WriteLine() metoden för att visa värdet.

Anmärkning

Du kommer att undersöka koden i detalj senare i den här lektionen.
Klicka på Spara på Visual Studio Code-menyn.
Högerklicka på TestProject för att öppna en terminal på mappen TestProject och välj sedan Öppna i integrerad terminal.

Observera att terminalpanelen innehåller en kommandotolk som visar en mappsökväg. Till exempel:
```
C:\Users\someuser\Desktop\CsharpProjects\TestProject>
```
När du använder terminalen för att köra .NET CLI-kommandon körs kommandon från den mappplats som visas. Kontrollera att kodmappen matchar mappsökvägen som visas i kommandotolken innan du skapar eller kör koden.
I kommandotolken i Terminal skriver du dotnet run och trycker sedan på Retur för att köra koden.

Observera att ett tal från 1 till 6 visas i konsolens utdata (antalet punkter på tärningarna). Om du kör koden tillräckligt många gånger visas var och en av siffrorna 1–6.
Det tar en minut att undersöka syntaxen som används för att komma åt Next() metoderna och WriteLine() .

Observera att du använder olika tekniker för att komma åt metoderna.
```
Random dice = new Random();
int roll = dice.Next(1, 7);
Console.WriteLine(roll);
```
På den tredje kodraden Console inkluderar du en referens till klassen och anropar Console.WriteLine() metoden direkt. Du använder dock en annan teknik för att anropa Random.Next() metoden. Anledningen till att du använder två olika tekniker är att vissa metoder är "tillståndskänsliga" och andra är "tillståndslösa". Du undersöker skillnaden mellan tillståndskänsliga och tillståndslösa metoder i nästa avsnitt.

Tillståndskänsliga och tillståndslösa metoder

I programutvecklingsprojekt används termen tillstånd för att beskriva körningsmiljöns villkor vid en viss tidpunkt. När koden körs rad för rad lagras värden i variabler. Vid varje given tidpunkt så är programmets tillstånd samlingen av alla värden som lagras i minnet.

En del metoder är inte beroende av programmets aktuella tillstånd för att fungera korrekt. Med andra ord implementeras tillståndslösa metoder så att de kan fungera utan att referera till eller ändra värden som redan lagras i minnet. Tillståndslösa metoder kallas även statiska metoder.

Metoden Console.WriteLine() behöver till exempel inte några värden som lagras i minnet. Den utför sin funktion utan att programmets tillstånd påverkas alls.

Andra metoder behöver dock åtkomst till programmets tillstånd för att fungera korrekt. Med andra ord är tillståndskänsliga metoder byggda på ett sådant sätt att de förlitar sig på värden som lagras i minnet av tidigare kodrader som redan har körts. Eller så ändrar de programmets tillstånd genom att uppdatera eller lagra nya värden i minnet. De kallas även instansmetoder.

Tillståndskänsliga metoder (instans) håller reda på sitt tillstånd i fält, som är variabler som definierats i klassen. Varje ny instans av klassen har en egen uppsättning fält där tillståndet lagras.

Samma klass kan ha både tillståndskänsliga och tillståndslösa metoder. Men när du behöver anropa tillståndskänsliga metoder måste du först skapa en instans av klassen så att metoden kan komma åt tillståndet.

Skapa en instans av en klass

En instans av en klass anropas som ett objekt. Om du vill skapa en ny instans av en klass använder du operatorn new. Ta följande kodrad som exempel. Den skapar en ny instans av klassen Random i ett nytt objekt som heter dice:

Random dice = new Random();

Operatorn new gör flera viktiga saker:

Först begär den en adress i datorminnet som är tillräckligt stor för att lagra ett nytt objekt baserat på klassen Random.
Den skapar det nya objektet och lagrar det på minnesadressen.
Den returnerar minnesadressen så att den kan sparas i dice objektet.

dice När objektet refereras till i kod utför .NET Runtime sedan en sökning i bakgrunden för att ge illusionen att du arbetar direkt med själva objektet.

Koden använder objektet dice som en variabel som lagrar klassens Random tillstånd. När du anropar Next() metoden för dice objektet använder metoden tillståndet som lagras i dice objektet för att generera ett slumpmässigt tal.

Med den senaste versionen av .NET Runtime kan du instansiera ett objekt utan att behöva upprepa typnamnet (måltypad konstruktoranrop). Följande kod skapar till exempel en ny instans av Random klassen:

Random dice = new();

Avsikten är att förenkla kodens läsbarhet. Du använder alltid parenteser när du skriver ett måltypat new uttryck.

Varför är metoden Next() tillståndskänslig?

Du kanske undrar varför metoden Next() är implementerad som en tillståndskänslig metod? Kunde inte de som skrev .NET-klassbiblioteks komma på ett sätt att generera slumptal oberoende av programmets tillstånd? Och vad är det egentligen som lagras eller refereras med metoden Next()?

Det här är bra frågor. På hög nivå är datorer bra på att följa specifika instruktioner och generera tillförlitliga och repeterbara resultat. De som skrev metoden Next() försökte efterhärma slumpmässighet genom att använda den aktuella tidpunkten ned till delar av millisekunder som utgångsvärde i en algoritm som varje gång genererar ett nytt tal. Talen är inte helt slumpmässiga, men tillräckligt nära för de flesta tillämpningar. Det tillstånd som samlas in och underhålls under objektets dice livslängd är startvärdet. Varje efterföljande anrop till metoden Next() kör algoritmen igen, men utgångsvärdet ändras så att inte samma tal (nödvändigtvis) returneras.

Om du vill använda Random.Next() metoden behöver du dock inte förstå hur den fungerar. Det viktiga att veta är att vissa metoder kräver att du skapar en instans av en klass innan du anropar dem, medan andra inte gör det.

Hur kan du avgöra om du behöver skapa en instans av en klass innan du anropar dess metoder?

En metod för att avgöra om en metod är tillståndskänslig eller tillståndslös är att läsa dokumentationen. Dokumentationen innehåller exempel som visar om metoden måste anropas från objektinstansen eller direkt från klassen.

Anmärkning

Du kan behöva rulla nedåt på dokumentationssidan för att hitta kodexemplen.

Som ett alternativ till att söka igenom produktdokumentationen kan du försöka komma åt metoden direkt från själva klassen. Om det fungerar vet du att det är en tillståndslös metod. Det värsta som kan hända är att du får ett kompileringsfel.

Prova att Random.Next() komma åt metoden direkt och se vad som händer.

Ange följande kodrad i Visual Studio Code-redigeraren:
```
int result = Random.Next();
```
Du vet redan att det Next() är en tillståndskänslig metod, men det här exemplet visar hur Visual Studio Code-redigeraren reagerar när du försöker komma åt en metod felaktigt.
Observera att en röd vågig linje visas under Random.Next, vilket indikerar att du har ett kompileringsfel.

Om den metod som du är intresserad av att använda är tillståndslös visas ingen röd vågig linje.
Hovra muspekaren över den röda vågiga linjen.

Ett popup-fönster bör visas med följande meddelande:
```
(1,14): error CS0120: An object reference is required for the non-static field, method, or property 'Random.Next()'
```
Som du såg i koden i början av lektionen kan du åtgärda det här felet genom att skapa en instans av Random klassen innan du Next() kommer åt metoden. Till exempel:
```
Random dice = new Random();
int roll = dice.Next();
```
I det här fallet Next() anropas metoden utan indataparametrar.

Sammanfattning

När du ska anropa metoder för en klass i .NET-klassbiblioteket använder du formatet ClassName.MethodName(), där symbolen . är åtkomstoperatorn för metoder som definierats i klassen och () är operatorn för metodanrop.
När du anropar en tillståndslös metod behöver du inte skapa någon ny instans av klassen först.
När du anropar en tillståndskänslig metod måste du skapa en instans av klassen och anropa metoden för objektet.
Använd operatorn new när du ska skapa en ny instans av en klass.
En instans av en klass anropas som ett objekt.

Feedback

Var den här sidan till hjälp?

Övning – Anropa metoderna för en .NET-klass

Kontrollera dina kunskaper

Feedback