Anatomia di un metodo

Il Framework .NET mette a disposizione dello sviluppatore un enorme numero di classi contenenti metodi davvero utili, già scritti e pronti all'uso, ma solo in pochi casi questi bastano a creare un'applicazione ben strutturata ed elegante. Per questo motivo, è possibile creare nuovi metodi - procedure o funzioni che siano - ed usarli comodamente nel programma. Per lo più, si crea un metodo per separare logicamente una certa parte di codice dal resto del sorgente: questo serve in primis a rendere il listato più leggibile, più consultabile e meno prolisso, ed inoltre ha la funzione di racchiudere sotto un unico nome (il nome del metodo) una serie più o meno grande di istruzioni.
Un metodo è costituito essenzialmente da tre parti:

• Nome : un identificatore che si può usare in altre parti del programma per invocare il metodo, ossia per eseguire le istruzioni di cui esso consta;
• Elenco dei parametri : un elenco di variabili attraverso i quali il metodo può scambiare dati con il programma;
• Corpo : contiene il codice effettivo associato al metodo, quindi tutte le istruzioni e le operazioni che esso deve eseguire

Ma ora scendiamo un po' più nello specifico...

Procedure senza parametri

Il caso più semplice di metodo consiste in una procedura senza parametri: essa costituisce, grosso modo, un sottoprogramma a sè stante, che può essere richiamato semplicemente scrivendone il nome. La sua sintassi è molto semplice:

Sub [nome]()
    'istruzioni
End Sub 

Credo che vi sia subito balzato agli occhi che questo è esattamente lo stesso modo in cui viene dichiarata la Sub Main: pertanto, ora posso dirlo, Main è un metodo e, nella maggior parte dei casi, una procedura senza parametri (ma si tratta solo di un caso particolare, come vedremo fra poco). Quando il programma inizia, Main è il primo metodo eseguito: al suo interno, ossia nel suo corpo, risiede il codice del programma. Inoltre, poiché facenti parti del novero delle entità presenti in una classe, i metodi sono membri di classe: devono, perciò, essere dichiarati a livello di classe. Con questa locuzione abbastanza comune nell'ambito della programmazione si intende l'atto di dichiarare qualcosa all'interno del corpo di una classe, ma fuori dal corpo di un qualsiasi suo membro. Ad esempio, la dichiarazione seguente è corretta:

Module Module1
    Sub Esempio()
        'istruzioni
    End Sub
    
    Sub Main()
        'istruzioni
    End Sub
End Module 

mentre la prossima è SBAGLIATA:

Module Module1
    Sub Main()
        Sub Esempio()
            'istruzioni
        End Sub
        'istruzioni
    End Sub
End Module 

Allo stesso modo, i metodi sono l'unica categoria, oltre alle proprietà e agli operatori, a poter contenere delle istruzioni: sono strumenti "attivi" di programmazione e solo loro possono eseguire istruzioni. Quindi astenetevi dallo scrivere un abominio del genere:

Module Module1
    Sub Main()
        'istruzioni
    End Sub
    Console.WriteLine()
End Sub 

E' totalmente e concettualmente sbagliato. Ma ora veniamo al dunque con un esempio:

Module Module1
    'Dichiarazione di una procedura: il suo nome è "FindDay", il
    'suo elenco di parametri è vuoto, e il suo corpo è
    'rappresentato da tutto il codice compreso tra "Sub FindDay()"
    'ed "End Sub".
    Sub FindDay()
        Dim StrDate As String
        Console.Write("Inserisci giorno (dd/mm/yyyy): ")
        StrDate = Console.ReadLine

        Dim D As Date
        'La funzione Date.TryParse tenta di convertire la stringa
        'StrDate in una variabile di tipo Date (che è un tipo
        'base). Se ci riesce, ossia non ci sono errori nella
        'data digitata, restituisce True e deposita il valore
        'ottenuto in D; se, al contrario, non ci riesce,
        'restituisce False e D resta vuota.
        'Quando una data non viene inizializzata, dato che è un
        'tipo value, contiene un valore predefinito, il primo
        'Gennaio dell'anno 1 d.C. a mezzogiorno in punto.
        If Date.TryParse(StrDate, D) Then
            'D.DayOfWeek contiene il giorno della settimana di D
            '(lunedì, martedì, eccetera...), ma in un
            'formato speciale, l'Enumeratore, che vedremo nei
            'prossimi capitoli.
            'Il ".ToString()" converte questo valore in una
            'stringa, ossia in un testo leggibile: i giorni della
            'settimana, però, sono in inglese
            Console.WriteLine(D.DayOfWeek.ToString())
        Else
            Console.WriteLine(StrDate & " non è una data valida!")
        End If
    End Sub

    'Altra procedura, simile alla prima
    Sub CalculateDaysDifference()
        Dim StrDate1, StrDate2 As String
        Console.Write("Inserisci il primo giorno (dd/mm/yyyy): ")
        StrDate1 = Console.ReadLine
        Console.Write("Inserisci il secondo giorno (dd/mm/yyyy): ")
        StrDate2 = Console.ReadLine

        Dim Date1, Date2 As Date

        If Date.TryParse(StrDate1, Date1) And _
           Date.TryParse(StrDate2, Date2) Then
            'La differenza tra due date restituisce il tempo
            'trascorso tra l'una e l'altra. In questo caso noi
            'prendiamo solo i giorni
            Console.WriteLine((Date2 - Date1).Days)
        Else
            Console.WriteLine("Inserire due date valide!")
        End If
    End Sub

    Sub Main()
        'Command è una variabile di tipo char (carattere) che
        'conterrà una lettera indicante quale compito eseguire
        Dim Command As Char

        Do
            Console.Clear()
            Console.WriteLine("Qualche operazione con le date:")
            Console.WriteLine("- Premere F per sapere in che giorno " & _
                "della settimana cade una certa data;")
            Console.WriteLine("- Premere D per calcolare la differenza tra due date;")
            Console.WriteLine("- Premere E per uscire.")
            'Console.ReadKey() è la funzione che abbiamo sempre
            'usato fin'ora per fermare il programma in attesa della
            'pressione di un pulsante. Come vedremo fra breve, non 
            'è necessario usare il valore restituito da una
            'funzione, ma in questo caso ci serve. Ciò che 
            'ReadKey restituisce è qualcosa che non ho ancora
            'trattato. Per ora basti sapere che 
            'Console.ReadKey().KeyChar contiene l'ultimo carattere 
            'premuto sulla tastiera
            Command = Console.ReadKey().KeyChar
            'Analizza il valore di Command
            Select Case Command
                Case "f"
                    'Invoca la procedura FindDay()
                    FindDay()
                Case "d"
                    'Invoca la procedura CalculateDaysDifference()
                    CalculateDaysDifference()
                Case "e"
                    'Esce dal ciclo
                    Exit Do
                Case Else
                    Console.WriteLine("Comando non riconosciuto!")
            End Select
            Console.ReadKey()
        Loop
    End Sub
End Module 

In questo primo caso, le due procedure dichiarate sono effettivamente sottoprogrammi a sé stanti: non hanno nulla in comune con il modulo (eccetto il semplice fatto di esserne membri), né con Main, ossia non scambiano alcun tipo di informazione con essi; sono come degli ingranaggi sigillati all'interno di una scatola chiusa. A questo riguardo, bisogna inserire una precisazione sulle variabili dichiarate ed usate all'interno di un metodo, qualsiasi esso sia. Esse si dicono locali o temporanee, poiché esistono solo all'interno del metodo e vengono distrutte quando il flusso di elaborazione ne raggiunge la fine. Anche sotto questo aspetto, si può notare come le procedure appena stilate siano particolarmente chiuse e restrittive. Tuttavia, si può benissimo far interagire un metodo con oggetti ed entità esterne, e questo approccio è decisamente più utile che non il semplice impacchettare ed etichettare blocchi di istruzioni in locazioni distinte. Nel prossimo esempio, la procedura attinge dati dal modulo, poiché in esso è dichiarata una variabile a livello di classe.

Module Module1
    'Questa variabile è dichiarata a livello di classe 
    '(o di modulo, in questo caso), perciò è accessibile
    'a tutti i membri del modulo, sempre seguendo il discorso
    'dei blocchi di codice fatto in precedenza
    Dim Total As Single = 0

    'Legge un numero da tastiera e lo somma al totale
    Sub Sum()
        Dim Number As Single = Console.ReadLine
        Total += Number
    End Sub

    'Legge un numero da tastiera e lo sottrae al totale
    Sub Subtract()
        Dim Number As Single = Console.ReadLine
        Total -= Number
    End Sub

    'Legge un numero da tastiera e divide il totale per
    'tale numero
    Sub Divide()
        Dim Number As Single = Console.ReadLine
        Total /= Number
    End Sub

    'Legge un numero da tastiera e moltiplica il totale
    'per tale numero
    Sub Multiply()
        Dim Number As Single = Console.ReadLine
        Total *= Number
    End Sub

    Sub Main()
        'Questa variabile conterrà il simbolo matematico
        'dell'operazione da eseguire
        Dim Operation As Char
        Do
            Console.Clear()
            Console.WriteLine("Risultato attuale: " & Total)
            Operation = Console.ReadKey().KeyChar
            Select Case Operation
                Case "+"
                    Sum()
                Case "-"
                    Subtract()
                Case "*"
                    Multiply()
                Case "/"
                    Divide()
                Case "e"
                    Exit Do
                Case Else
                    Console.WriteLine("Operatore non riconosciuto")
                    Console.ReadKey()
            End Select
        Loop
    End Sub
End Module 

Procedure con parametri

Avviandoci verso l'interazione sempre maggiore del metodo con l'ambiente in cui esso esiste, troviamo le procedure con parametri. Al contrario delle precedenti, esse possono ricevere e scambiare dati con il chiamante: con quest'ultimo termine ci si riferisce alla generica entità all'interno della quale il metodo in questione è stato invocato. I parametri sono come delle variabili locali fittizie: esistono solo all'interno del corpo, ma non sono dichiarate in esso, bensì nell'elenco dei parametri. Tale elenco deve essere specificato dopo il nome del metodo, racchiuso da una coppia di parentesi tonde, e ogni suo elemento deve essere separato dagli altri da virgole.

Sub [nome](ByVal [parametro1] As [tipo], ByVal [parametro2] As [tipo], ...)
    'istruzioni
End Sub 

Come si vede, anche la dichiarazione è abbastanza simile a quella di una variabile, fatta eccezione per la parola riservata ByVal, di cui tra poco vedremo l'utilià. Per introdurre semplicemente l'argomento, facciamo subito un esempio, riscrivendo l'ultimo codice proposto nel paragrafo precedente con l'aggiunta dei parametri:

Module Module1
    Dim Total As Single = 0

    Sub Sum(ByVal Number As Single)
        Total += Number
    End Sub

    Sub Subtract(ByVal Number As Single)
        Total -= Number
    End Sub

    Sub Divide(ByVal Number As Single)
        Total /= Number
    End Sub

    Sub Multiply(ByVal Number As Single)
        Total *= Number
    End Sub

    Sub Main()
        'Questa variabile conterrà il simbolo matematico
        'dell'operazione da eseguire
        Dim Operation As Char
        Do
            Console.Clear()
            Console.WriteLine("Risultato attuale: " & Total)
            Operation = Console.ReadKey().KeyChar
            Select Case Operation
                'Se si tratta di simboli accettabili
                Case "+", "-", "*", "/"
                    'Legge un numero da tastiera
                    Dim N As Single = Console.ReadLine
                    'E a seconda dell'operazione, utilizza una
                    'procedura piuttosto che un'altra
                    Select Case Operation
                        Case "+"
                            Sum(N)
                        Case "-"
                            Subtract(N)
                        Case "*"
                            Multiply(N)
                        Case "/"
                            Divide(N)
                    End Select
                Case "e"
                    Exit Do
                Case Else
                    Console.WriteLine("Operatore non riconosciuto")
                    Console.ReadKey()
            End Select
        Loop
    End Sub
End Module 

Richiamando, ad esempio, Sum(N) si invoca la procedura Sum e si assegna al parametro Number il valore di N: quindi, Number viene sommato a Total e il ciclo continua. Number, perciò, è un "segnaposto", che riceve solo durante l'esecuzione un valore preciso, che può anche essere, come in questo caso, il contenuto di un'altra variabile. Nel gergo tecnico, Number - ossia, più in generale, l'identificatore dichiarato nell'elenco dei parametri - si dice parametro formale, mentre N - ossia ciò che viene concretamente passato al metodo - si dice parametro attuale. Non ho volutamente assegnato al parametro attuale lo stesso nome di quello formale, anche se è del tutto lecito farlo: ho agito in questo modo per far capire che non è necessario nessun legame particolare tra i due; l'unico vincolo che deve sussistere risiede nel fatto che parametro formale ed attuale abbiano lo stesso tipo. Quest'ultima asserzione, del resto, è abbastanza ovvia: se richiamassimo Sum("ciao") come farebbe il programma a sommare una stringa ("ciao") ad un numero (Total)?
Ora proviamo a modificare il codice precedente riassumendo tutte le operazioni in una sola procedura, a cui, però, vengono passati due parametri: il numero e l'operatore da usare.

Module Module1
    Dim Total As Single = 0

    Sub DoOperation(ByVal Number As Single, ByVal Op As Char)
        Select Case Op
            Case "+"
                Total += Number
            Case "-"
                Total -= Number
            Case "*"
                Total *= Number
            Case "/"
                Total /= Number
        End Select
    End Sub

    Sub Main()
        Dim Operation As Char
        Do
            Console.Clear()
            Console.WriteLine("Risultato attuale: " & Total)
            Operation = Console.ReadKey().KeyChar
            Select Case Operation
                Case "+", "-", "*", "/"
                    Dim N As Single = Console.ReadLine
                    'A questa procedura vengono passati due
                    'parametri: il primo è il numero da
                    'aggiungere/sottrarre/moltiplicare/dividere
                    'a Total; il secondo è il simbolo
                    'matematico che rappresenta l'operazione
                    'da eseguire
                    DoOperation(N, Operation)
                Case "e"
                    Exit Do
                Case Else
                    Console.WriteLine("Operatore non riconosciuto")
                    Console.ReadKey()
            End Select
        Loop
    End Sub
End Module 

Passare parametri al programma da riga di comando

Come avevo accennato in precedenza, non è sempre vero che Main è una procedura senza parametri. Infatti, è possibile dichiarare Main in un altro modo, che le consente di ottenere informazioni quando il programma viene eseguito da riga di comando. In quest'ultimo caso, Main viene dichiarata con un solo argomento, un array di stringhe:

Module Module1
    Sub Main(ByVal Args() As String)
        If Args.Length = 0 Then
            'Se la lunghezza dell'array è 0, significa che è vuoto
            'e quindi non è stato passato nessun parametro a riga
            'di comando. Scrive a schermo come utilizzare
            'il programma
            Console.WriteLine("Utilizzo: nomeprogramma.exe tuonome")
        Else
            'Args ha almeno un elemento. Potrebbe anche averne di
            'più, ma a noi interessa solo il primo.
            'Saluta l'utente con il nome passato da riga di comando
            Console.WriteLine("Ciao " & Args(0) & "!")
        End If
        Console.ReadKey()
    End Sub
End Module

Per provarlo, potete usare cmd.exe, il prompt dei comandi. Io ho digitato:

CD "C:UsersTotemDocumentsVisual Studio 2008ProjectsConsoleApplication2inDebug"
ConsoleApplication2.exe Totem

La prima istruzione per cambiare la directory di lavoro, la seconda l'invocazione vera e propria del programma, dove "Totem" è l'unico argomento passatogli: una volta premuto invio, apparirà il messaggio "Ciao Totem!". In alternativa, è possibile specificare gli argomenti passati nella casella di testo "Command line arguments" presente nella scheda Debug delle proprietà di progetto. Per accedere alle proprietà di progetto, cliccate col pulsante destro sul nome del progetto nella finestra a destra, quindi scegliete Properties e recatevi alla tabella Debug: