Esercizio - Usare i parametri nei metodi

10 minuti

Quando si creano metodi, spesso si vogliono fornire alcune informazioni per il metodo da usare. Le informazioni utilizzate da un metodo sono denominate parametro . È possibile fornire quanti parametri siano necessari per completare il compito, o nessuno.

I termini 'parameter' e 'argument' vengono spesso usati in modo intercambiabile. Tuttavia, 'parameter' fa riferimento alla variabile nella firma del metodo. L'argomento è il valore passato quando viene chiamato il metodo .

Aggiungere parametri ai metodi

I parametri in un metodo funzionano in modo simile alle variabili. Un parametro viene definito specificando il tipo di dati seguito dal nome del parametro. I parametri vengono dichiarati nella firma del metodo e i valori per i parametri vengono forniti dal chiamante del metodo anziché essere inizializzati all'interno del metodo stesso. Osservare il codice seguente:

	CountTo(5);

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

In questo esempio il metodo CountTo accetta un parametro integer denominato max. Si fa riferimento al parametro nel ciclo for del metodo. Quando CountTo viene chiamato, l'intero 5 viene fornito come argomento.

In questo esercizio si apprenderà come creare e usare i propri parametri del metodo.

Preparare l'ambiente di scrittura del codice

Questo modulo include attività pratiche che illustrano il processo di compilazione ed esecuzione del codice dimostrativo. È consigliabile completare queste attività usando Visual Studio Code come ambiente di sviluppo. L'uso di Visual Studio Code per queste attività consente di acquisire familiarità nella scrittura e nell'esecuzione del codice in un ambiente di sviluppo usato da professionisti di tutto il mondo.

Apri Visual Studio Code.

Per aprire Visual Studio Code, è possibile usare il menu Start di Windows (o una risorsa equivalente per un altro sistema operativo).
Scegliere Apri cartella dal menu File di Visual Studio Code.
Nella finestra di dialogo Apri cartella passare alla cartella Desktop di Windows.

Se si dispone di un percorso di cartella diverso in cui si conservano i progetti di codice, è possibile usare tale percorso. Per questo training, l'aspetto importante è avere una posizione facile da individuare e ricordare.
Nella finestra di dialogo Apri cartellaselezionare Seleziona cartella.

Se viene visualizzata una finestra di dialogo di sicurezza che chiede se si considera attendibile gli autori, selezionare Sì.
Nel menu Terminale di Visual Studio Code selezionare Nuovo terminale.

Si noti che un prompt dei comandi nel pannello Terminale visualizza il percorso della cartella corrente. Per esempio:
```
C:\Users\someuser\Desktop>
```
Annotazioni

Se si lavora sul proprio PC anziché in un ambiente sandbox o in un ambiente ospitato e sono stati completati altri moduli di Microsoft Learn in questa serie C#, è possibile che sia già stata creata una cartella di progetto per gli esempi di codice. In tal caso, è possibile ignorare il passaggio successivo, usato per creare un'app console nella cartella TestProject.
Al prompt dei comandi del terminale, per creare una nuova applicazione console in una cartella specificata, digitare dotnet new console -o ./CsharpProjects/TestProject e quindi premere INVIO.

Questo comando dell'interfaccia della riga di comando .NET usa un modello di programma .NET per creare un nuovo progetto di applicazione console C# nel percorso della cartella specificato. Il comando crea le cartelle CsharpProjects e TestProject e usa TestProject come nome del file .csproj.
Nel pannello EXPLORER espandere la cartella CsharpProjects .

Verrà visualizzata la cartella TestProject e due file, un file di programma C# denominato Program.cs e un file di progetto C# denominato TestProject.csproj.
Nel pannello EXPLORER selezionare Program.cs per visualizzare il file di codice nel pannello Editor.
Eliminare le righe di codice esistenti.

Questo progetto console C# verrà usato per creare, compilare ed eseguire esempi di codice durante questo modulo.
Chiudere il pannello Terminale.

Creare un metodo con parametri

In questa attività si creerà un metodo che regola gli orari pianificati in un fuso orario GMT diverso. Il metodo deve accettare un elenco di orari, il fuso orario corrente e il nuovo fuso orario. È ora di iniziare.

Immettere il codice seguente nell'editor di Visual Studio Code:
```
int[] schedule = {800, 1200, 1600, 2000};
```
Per creare un metodo con parametri, immettere il codice seguente in una nuova riga vuota:
```
void DisplayAdjustedTimes(int[] times, int currentGMT, int newGMT) 
{

}
```
Si noti che i parametri vengono dichiarati in modo simile al modo in cui si dichiarano le variabili, usando il tipo di dati seguito dal nome della variabile. È possibile usare parametri di qualsiasi tipo di dati, ad esempio string, , boolint, matrici e altro ancora. Più parametri in un metodo sono sempre separati da virgole.
Immettere il codice seguente nel DisplayAdjustedTimes metodo :
```
int diff = 0;
if (Math.Abs(newGMT) > 12 || Math.Abs(currentGMT) > 12)
{
    Console.WriteLine("Invalid GMT");
}
```
Si noti come non è necessario dichiarare le variabili newGMT e currentGMT poiché sono già dichiarate nella firma del metodo. Inoltre, non si inizializzano le variabili perché il metodo presuppone che il chiamante fornisca tali argomenti con valori assegnati.

In questo passaggio si crea int diff per archiviare la differenza di tempo e quindi verificare che i valori GMT forniti siano compresi tra -12 e 12. L'uso Math.Abs di fornisce il valore assoluto di un numero, quindi i valori GMT non sono validi se sono maggiori di 12.
Per calcolare la differenza di tempo, aggiornare il DisplayAdjustedTimes metodo nel modo seguente:
```
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));
}
```
In questo codice si verifica se è necessario aggiungere o sottrarre i valori assoluti dei fusi orari GMT per ottenere la differenza in ore. Se i valori GMT condividono lo stesso segno (sia positivo che negativo), la differenza di ore è uguale alla differenza tra i due numeri. Se i valori GMT hanno segni opposti, la differenza è uguale alla somma dei due numeri. Poiché le ore sono rappresentate in centinaia, si moltiplica il risultato per 100.

Per visualizzare i risultati, immettere il codice seguente alla fine del DisplayAdjustedTimes metodo :

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

Per chiamare il metodo, immettere il codice seguente dopo la dichiarazione di int[] schedule variabile:
```
DisplayAdjustedTimes(schedule, 6, -6);
```
Si noti che sia le variabili che i valori letterali possono essere forniti come argomenti a un metodo. Usando i parametri di input, il metodo non è limitato all'uso dei valori delle variabili globali.

Controllare il lavoro svolto

In questa attività si eseguirà l'applicazione dal terminale integrato e si verificherà che il codice funzioni correttamente. Iniziamo.

Salvare il lavoro usando CTRL + S o il menu File di Visual Studio Code.
Se necessario, aprire il pannello Terminale integrato di Visual Studio Code.

Nel pannello EXPLORER, per aprire un terminale nel percorso della cartella TestProject, fare clic con il pulsante destro del mouse su TestProject e quindi scegliere Apri nel terminale integrato.
Al prompt dei comandi del terminale immettere dotnet run
Verificare che il codice produca l'output seguente:
```
800 -> 2000
1200 -> 0
1600 -> 400
2000 -> 800
```
Se il codice visualizza risultati diversi, è necessario esaminarlo per trovare l'errore e apportare aggiornamenti. Eseguire di nuovo il codice per verificare che il problema sia stato risolto. Continuare ad aggiornare ed eseguire il codice fino a quando non produce i risultati previsti.

Riepilogo

Ecco quanto appreso finora sui parametri:

Le informazioni possono essere passate ai metodi sotto forma di parametri.
I parametri vengono dichiarati nella firma del metodo.
Più parametri sono separati da virgole.
I metodi possono accettare argomenti variabili o letterali.

Commenti e suggerimenti

Questa pagina è stata utile?