Dichiarazione di un Metodo in C#

Punto di dichiarazione di un Metodo

Anche se non abbiamo ancora spiegato come dichiarare classi o come utilizzarle, implicitamente l'abbiamo comunque fatto negli esempi delle lezioni precedenti. Sappiamo che ogni classe ha parentesi graffe di apertura e chiusura, { e }, tra le quali viene inserito il codice del programma.

Una descrizione più dettagliata di come esse funzionano la vedremo più avanti nel capitolo dedicato alle classi, tuttavia lo menzioniamo qui, perché un metodo esiste solo se è dichiarato tra le parentesi graffe di apertura e chiusura di una classe: { e }.

Inoltre, un metodo non può essere dichiarato all'interno del corpo di un altro metodo (questo sarà chiarito più avanti).

Un esempio tipico di un metodo è il già noto metodo Main() che è sempre dichiarato tra le parentesi graffe di apertura e chiusura della nostra classe. Un esempio di questo è mostrato di seguito:

public class CiaoCSharp
{ // Parentesi graffa di apertura della classe

    // Dichiarazione del nostro metodo
    // tra le parentesi graffe del corpo della classe
    static void Main(string[] args)
    {
        Console.WriteLine("Ciao C#!");
    }

} // Parentesi graffa di chiusura della classe

Dichiarazione di un metodo

Dichiarare un metodo significa registrare il metodo nel nostro programma.

La sintassi per dichiarare un metodo è la seguente:

[static] tipo_di_ritorno nome_metodo([lista_parametri])

Ci sono alcuni elementi obbligatori per dichiarare un metodo, mentre altri sono opzionali:

• tipo_di_ritorno: Tipo del risultato, restituito dal metodo;
• nome_metodo: Nome del metodo;
• lista_parametri: Elenco dei parametri del metodo. Si tratta di un elemento opzionale, infatti può essere un elenco vuoto o può consistere in una sequenza di dichiarazioni di parametri.

Per chiarire gli elementi della dichiarazione del metodo, possiamo usare il metodo Main dell'esempio HelloCSharp mostrato nel blocco precedente:

static void Main(string[] args)

Come si può vedere, il tipo di valore restituito è void (cioè quel metodo non restituisce un risultato), il nome del metodo è Main, seguito da parentesi tonde, tra le quali c'è un elenco con i parametri del metodo. Nell'esempio particolare è presente effettivamente solo un parametro: l'array string[] args.

La sequenza, in cui gli elementi di un metodo sono scritti, è strettamente definita.

Sempre, al primo posto, c'è il tipo del valore che il metodo restituisce tipo_di_ritorno, seguito dal nome del metodo nome_metodo e dall'elenco dei parametri alla fine lista_parametri posto tra parentesi tonde: ( e ).

Facoltativamente, le dichiarazioni possono avere modificatori di accesso (come public e static).

L'elenco dei parametri può essere vuoto. In tal caso, l'unica cosa che dobbiamo fare è digitare () dopo il nome del metodo. Anche se il metodo non ha parametri, le parentesi tonde devono seguire il suo nome nella dichiarazione.

Per ora non ci concentreremo su cosa sia il tipo di ritorno e, infatti, useremo solo void, il che significa che il metodo non restituirà nulla. Più avanti, vedremo come questo può essere cambiato.

La parola chiave static nella descrizione della dichiarazione sopra non è obbligatoria ma dovrebbe essere usata nei piccoli programmi semplici. Ha uno scopo speciale che sarà spiegato più avanti. Ora i metodi che useremo negli esempi, includeranno la parola chiave static nella loro dichiarazione.

Maggiori informazioni sui metodi che non sono dichiarati come static saranno discusse nel capitolo dedicato alle classi.

Ricapitolando:

[static] tipo_di_ritorno nome_metodo([lista_parametri])

Firma del metodo

Prima di procedere con gli elementi di base della dichiarazione del metodo, dobbiamo prestare attenzione a qualcosa di più importante.

Nella programmazione orientata agli oggetti, un metodo è identificato da una coppia di elementi della sua dichiarazione: nome del metodo e elenco dei parametri.

Questi due elementi definiscono la cosiddetta specifica del metodo più spesso chiamata come firma del metodo (in inglese method's signature).

Il linguaggio C# distingue due metodi in base alla loro firma. Da ciò ne consegue che due metodi possono avere lo stesso nome, ma devono avere firme diverse. Questo concetto lo studieremo più avanti e prende il nome di overloading dei metodi.

Qui dobbiamo notare che il tipo di valore restituito di un metodo è solo parte della sua dichiarazione, non della sua firma.

Una spiegazione più dettagliata sul perché il tipo di valore restituito non fa parte della firma del metodo la analizzeremo nelle lezioni successive.

Vediamo un esempio. Prendiamo il metodo che segue:

static void stampaMessaggio(string messaggio)
{
    Console.WriteLine(messaggio);
}

In questo caso la firma del metodo è: stampaMessaggio(string messaggio).

Nomi dei metodi

Ogni metodo svolge un particolare compito del problema complessivo che il nostro programma deve risolvere.

Il nome del metodo viene utilizzato quando il metodo viene chiamato. Ogni volta che chiamiamo (invochiamo) un particolare metodo, digitiamo il suo nome e, se necessario, passiamo valori (se ce ne sono).

Nell'esempio seguente, il nome del nostro metodo è StampaSaluto:

static void StampaSaluto() {
    Console.WriteLine("Ciao!");
}

Regole per nominare un metodo

Si raccomanda, quando si dichiara un metodo, di seguire le regole per la denominazione dei metodi suggerite da Microsoft:

• Il nome di un metodo deve iniziare con una lettera maiuscola;
• Deve essere applicata la regola PascalCase, cioè ogni nuova parola, che si concatena per formare il nome del metodo, deve iniziare con una lettera maiuscola;
• Si consiglia che il nome del metodo debba consistere in un verbo, o verbo e sostantivo.

Si noti che queste regole non sono obbligatorie, ma sono delle raccomandazioni.

Se vogliamo che il nostro codice C# segua lo stile di tutti i buoni programmatori del mondo, dobbiamo usare la convenzione del codice Microsoft. Torneremo su questo punto nelle prossime lezioni.

Ecco alcuni esempi di metodi ben nominati:

Stampa
GetNome
CalcolaPrezzo
ImpostaNomeUtente

E alcuni esempi di metodi mal nominati:

Abc11
Verde___Rosso
foo
_Bar

È molto importante che il nome del metodo descriva lo scopo del metodo. Il razionale dietro questa pratica è che quando una persona che non è familiare con il nostro programma legge il nome del metodo, può facilmente capire cosa fa quel metodo, senza la necessità di guardare il codice sorgente del metodo stesso.

Modificatori

Un modificatore è una parola chiave in C#, che fornisce informazioni aggiuntive al compilatore per un determinato codice.

Abbiamo già incontrato alcuni modificatori: public e static. Ora descriveremo brevemente cosa sono effettivamente i modificatori. Una descrizione dettagliata la vedremo quando studieremo le classi.

Quindi iniziamo con un esempio:

public static void StampaSaluto()
{
    Console.WriteLine("Salve!");
    Console.WriteLine("Come si va?");
}

Con questo esempio definiamo un metodo pubblico con il modificatore public.

È un tipo speciale di modificatore, chiamato anche modificatore di accesso e viene utilizzato per mostrare che il metodo può essere chiamato da qualsiasi classe C#, indipendentemente da dove si trova. I modificatori pubblici non sono limitati nel significato di chi può chiamarli.

Un altro esempio di modificatore di accesso, che possiamo incontrare, è il modificatore private. La sua funzione è opposta a quella del public, cioè se un metodo è dichiarato con il modificatore di accesso private, non può essere chiamato da nessuna parte, tranne che dalla classe in cui è dichiarato.

Se un metodo è dichiarato senza un modificatore di accesso (né public né private), è accessibile da tutte le classi nell'assembly corrente, ma non accessibile per nessun altro assembly (diciamo da altri progetti in Visual Studio).

Per lo stesso motivo, quando scriviamo piccoli programmi, come quelli in questo capitolo, non specificheremo modificatori di accesso.

Per ora, l'unica cosa che deve essere appresa è che nella dichiarazione del metodo non può esserci più di un modificatore di accesso.

Quando un metodo ha la parola chiave static, nella sua dichiarazione, questo metodo è chiamato metodo statico. Per chiamare un metodo statico non è necessario avere un'istanza di una classe in cui è dichiarato il metodo statico.

Per ora basti sapere che, se non dobbiamo usare classi, i metodi devono essere statici. Chiariremo le differenze tra metodi statici e non statici quando studieremo le classi.

Gli usi specifici dei modificatori di accesso saranno più chiari quando studieremo le classi.

In Sintesi

In questa lezione abbiamo studiato che:

• Un metodo è una parte fondamentale di un programma; in altri linguaggi di programmazione, i metodi sono chiamati funzioni o procedure;
• Un metodo può risolvere un determinato problema, può prendere parametri in ingresso e può restituire un risultato;
• Un metodo rappresenta tutte le conversioni di dati che un programma fa per risolvere un compito particolare;
• Un metodo è identificato dalla sua firma, cioè dal suo nome e dalla lista dei parametri;
• Il nome di un metodo deve iniziare con una lettera maiuscola e deve seguire la regola PascalCase;
• Un metodo può avere modificatori di accesso, come public e private.

Nella prossima lezione studieremo come implementare un metodo in C#.