Övning – Använda parametrar i metoder

10 minuter

När du skapar metoder vill du ofta ange viss information för den metod som ska användas. Information som används av en metod kallas för en parameter. Du kan ange så många parametrar som behövs för att utföra uppgiften, eller ingen alls.

Termerna "parameter" och "argument" används ofta omväxlande. Parametern refererar dock till variabeln i metodsignaturen. Argumentet är det värde som skickas när metoden anropas.

Lägga till parametrar i metoder

Parametrar i en metod fungerar ungefär som variabler. En parameter definieras genom att ange datatypen följt av namnet på parametern. Parametrar deklareras i metodsignaturen och värdena för parametrarna tillhandahålls av metodanroparen i stället för att initieras i själva metoden. Överväg följande kod:

	CountTo(5);

	void CountTo(int max) 
	{
		for (int i = 0; i < max; i++)
		{
			Console.Write($"{i}, ");
		}
	}

I det här exemplet accepterar metoden CountTo en heltalsparameter med namnet max. Parametern refereras till i for metodens loop. När CountTo anropas anges heltalet 5 som ett argument.

I den här övningen får du lära dig hur du skapar och använder dina egna metodparametrar.

Förbereda din kodningsmiljö

Den här modulen innehåller praktiska aktiviteter som vägleder dig genom processen att skapa och köra demonstrationskod. 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 har 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 enkel 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.
Om du vill skapa ett nytt konsolprogram i en angiven mapp i terminalkommandot skriver du den nya dotnet-konsolen -o ./CsharpProjects/TestProject och trycker sedan på Retur.

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å .csproj filen.
I Explorer-panelen utökar 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.
Välj Program.cs för att visa kodfilen i redigeringspanelen i explorer-panelen.
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.

Skapa en metod med parametrar

I den här uppgiften skapar du en metod som justerar schemalagda tider till en annan tidszon för GMT. Metoden bör acceptera en lista med tider, den aktuella tidszonen och den nya tidszonen. Nu ska vi komma igång!

Ange följande kod i Visual Studio Code-redigeraren:
```
int[] schedule = {800, 1200, 1600, 2000};
```
Om du vill skapa en metod med parametrar anger du följande kod på en ny tom rad:
```
void DisplayAdjustedTimes(int[] times, int currentGMT, int newGMT) 
{

}
```
Observera att parametrar deklareras på samma sätt som du deklarerar variabler med hjälp av datatypen följt av variabelnamnet. Du kan använda parametrar av valfri datatyp, till exempel string, bool, int, matriser med mera! Flera parametrar i en metod är alltid kommaavgränsade.
Ange följande kod i DisplayAdjustedTimes metoden:
```
int diff = 0;
if (Math.Abs(newGMT) > 12 || Math.Abs(currentGMT) > 12)
{
    Console.WriteLine("Invalid GMT");
}
```
Observera hur du inte behöver deklarera variablerna newGMT och currentGMT eftersom de redan har deklarerats i metodsignaturen. Du initierar inte heller variablerna eftersom metoden förutsätter att anroparen tillhandahåller dessa argument med tilldelade värden.

I det här steget skapar int diff du för att lagra tidsskillnaden och kontrollerar sedan att de angivna GMT-värdena är mellan -12 och 12. Med hjälp Math.Abs av får du det absoluta värdet för ett tal, så GMT-värdena är ogiltiga om de är större än 12.
Om du vill beräkna tidsskillnaden uppdaterar du metoden enligt DisplayAdjustedTimes följande:
```
int diff = 0;
if (Math.Abs(newGMT) > 12 || Math.Abs(currentGMT) > 12)
{
    Console.WriteLine("Invalid GMT");
}
else if (newGMT <= 0 && currentGMT <= 0 || newGMT >= 0 && currentGMT >= 0) 
{
    diff = 100 * (Math.Abs(newGMT) - Math.Abs(currentGMT));
} 
else 
{
    diff = 100 * (Math.Abs(newGMT) + Math.Abs(currentGMT));
}
```
I den här koden kontrollerar du om du behöver lägga till eller subtrahera de absoluta värdena för GMT-tidszonerna för att få skillnaden i timmar. Om GMT-värdena delar samma tecken (både positiva eller båda negativa) är timskillnaden lika med skillnaden mellan de två talen. Om GMT-värdena har motsatta tecken är skillnaden lika med summan av de två talen. Eftersom timmar representeras i hundratals multiplicerar du resultatet med 100.

Om du vill visa resultatet anger du följande kod i slutet av DisplayAdjustedTimes metoden:

for (int i = 0; i < times.Length; i++) 
{
    int newTime = (times[i] + diff) % 2400;
    Console.WriteLine($"{times[i]} -> {newTime}");
}

Om du vill anropa din metod anger du följande kod efter variabeldeklarationen int[] schedule :
```
DisplayAdjustedTimes(schedule, 6, -6);
```
Observera att både variabler och literaler kan anges som argument till en metod. Med hjälp av indataparametrar är metoden inte begränsad till att använda värdena för globala variabler.

Kontrollera ditt arbete

I den här uppgiften kör du programmet från den integrerade terminalen och kontrollerar att koden fungerar korrekt. Nu ska vi komma igång.

Spara ditt arbete med Ctrl + S eller med hjälp av Visual Studio Code-menyn.
Om det behövs öppnar du Visual Studio Codes integrerade terminalpanel.

I explorer-panelen öppnar du en terminal på mappen TestProject genom att högerklicka på TestProject och sedan välja Öppna i integrerad terminal.
I kommandotolken i Terminal anger du dotnet run
Kontrollera att koden genererar följande utdata:
```
800 -> 2000
1200 -> 0
1600 -> 400
2000 -> 800
```
Om koden visar olika resultat måste du granska koden för att hitta felet och göra uppdateringar. Kör koden igen för att se om du har åtgärdat problemet. Fortsätt att uppdatera och köra koden tills koden ger förväntade resultat.

Sammanfattning

Här är vad du har lärt dig om parametrar hittills:

Information kan skickas till metoder i form av parametrar.
Parametrar deklareras i metodsignaturen.
Flera parametrar avgränsas med kommatecken.
Metoder kan acceptera variabel- eller literalargument.

Feedback

Var den här sidan till hjälp?