CREARE IL PROPRIO VIDEOGMAE IN C#: OTTAVA PARTE

FACCIAMOCI I METODI NOSTRI..

Su che ci siamo, un altro paio di lezioni sulle basi e poi entriamo nel mondo di XNA.
Abbiamo visto le classi, i metodi, le variabili e i tipi di dati.
Dobbiamo approfondire la questione metodi perchè in realtà abbiamo visto solo il metodo Main che sinceramente ci ha già rotto, no?

Il linguaggio incorpora migliaia di metodi scritti dai programmatori di C# (come WriteLine e ReadLine ) ed offre tutte le funzionalità necessarie alle nostre attività, dalla semplice visualizzazione di un messaggio sul monitor alla gestione di un database su Internet. Nonostante il linguaggio metta a disposizione tutte queste funzionalità per i nostri programmi e videogiochi, spesso si ha la necessità, data la natura specifica di un'applicazione, di doverne scrivere di nuovi che meglio si adattino alle nostre esigenze.
Proviamo ora a scrivere un nostro metodo e sopratutto a richiamarlo, cosa che non abbiamo ancora fatto visto che Main "si chiama da solo".
Partiremo sempre dal programmino "Evviva" ma questa volta non faremo eseguire WriteLine dal metodo Main ma da un nostro metodo che chiameremo saluto.


using System;

class Evviva
{
static void saluto()
{
Console.WriteLine("Evviva C# e XNA!");
}

static void Main()
{
saluto();
}


}



Questo codice scrive sulla console il nostro testo. Ma abbiamo usato un nostro metodo! Non è una cosa bellissima? mmh..
Vediamo cosa succede:
Niente di più facile, il metodo Main parte per primo come sempre e appena trova una riga di codice la esegue, per la precisione la riga con su scritto saluto(); esegue il metodo omonimo scritto poco sopra, appunto static void saluto() {..} che scrive la nostra stringa sullo schermo.
Dunque la riga saluto(); non fa altro che richiamare (e dunque eseguire) il metodo omonimo.



Esaminando il flusso di elaborazione e dunque la cronologia dell'esecuzione del programma:


using System;

class Evviva
{
static void saluto() // 4 <------Quarta riga eseguita, esecuzione del metodo saluto()
{ // 5 <------Quinta riga eseguita, apertura del metodo saluto()
Console.WriteLine("Evviva C# e XNA!"); //6 <------Sesta riga eseguita, stampa del messaggio
} // 7 <------Settima riga eseguita, chiususra del metodo saluto()

static void Main() // 1 <------Inizio programma
{ // 2 <------Seconda riga eseguita, apertura del metodo Main()
saluto(); // 3 <------Terza riga eseguita, richiama il metodo saluto() e sposta l'esecuzione su di esso
} // 8 <------Quinta riga eseguita, chiusura del metodo Main() e del programma


}


E se avessimo scritto prima un metodo e poi l'altro, così? :


using System;

class Evviva
{


static void Main()
{
saluto();
}

static void saluto()
{
Console.WriteLine("Evviva C# e XNA!");
}
}



Stessa cosa. Non cambierebbe assolutamente nulla, sarebbe indifferente, la sequenza di esecuzione resterebbe la stessa.





Ribadiamo il concetto che un metodo può definirsi come un blocco di codice autonomo che viene richiamato tramite il suo nome.

Cerchiamo di integrare quello che abbiamo imparato nella lezione precedente su if ed else con questa lezione sui metodi.
Riprendiamo il codice della lezione precedente. E creiamo due metodi che chiameremo Scrivi_si e Scrivi_no (scusate la mancanza di fantasia, voi ovviamente potrete chiamare i vostri metodi come meglio credete).


using System;

class Evviva
{

static void Main()
{
string pippo;

Console.WriteLine("Inserisci una stringa: ");

pippo = Console.ReadLine();

if (pippo == "Mario")
{
Scrivi_si(); //Se la condizione è vera esegue il metodo Scrivi_si()
}
else
{
Scrivi_no(); //Altrimenti, se la condizione è falsa, esegue il metodo Scrivi_no()
}

} //Chiudo il metodo Main



//Ecco qua sotto i nostri due metodi

static void Scrivi_si()
{
Console.WriteLine("Si, hai scritto Mario");
}


static void Scrivi_no()
{
Console.WriteLine("No.. ma che hai scritto? ");
}



}//Chiudo la classe



Abbiamo fatto eseguire uno o l'altro metodo a seconda della verifica dell'if.




Attenzione all'argomento di cui si discuterà ora.
Le famose parentesi dopo il metodo, sia nella "stesura" del metodo che nel "richiamo" e le paroline static e void presenti solo nella stesura.

Un metodo, in forma generale si può definire così:

modificatori tipo-di-ritorno nome-metodo (lista parametri)
{
blocco di codice del metodo
}

Quante belle cose nuove eh? No panic!
Iniziamo subito a dire che le cose che ho evidenziato in verde sono opzionali, ovvero possono essere omesse senza perdere la correttezza dell'istruzione.

Gli elementi indicati hanno la seguente descrizione:

modificatori (opzionali). Un modificatore è per esempio la parola static che abbiamo incontrato sul metodo Main. Sono delle particolari parole chiave che indicano il livello di "accessibilità" del metodo rispetto alla classe che lo contiene. Il concetto è più assimilabile sapendo che i modificatori che useremo saranno anche private e public che come suggeriscono i termini, rendono il metodo pubblico o privato cioè "richiamabile" o meno dal di fuori della classe in cui si trovano. Come detto è un parametro opzionale, vedremo in seguito dove sarà indicato utilizzare un modificatore specifico invece che un altro.

tipo-di-ritorno . Per esempio la parola void che abbiamo già incontrato, sempre sul metodo Main. Indica il tipo di dato che il metodo può restituire dopo che è stato eseguito, dove per tipo si intende uno dei tipi di dati che abbiamo visionato, come string, int ecc.. Se il metodo non deve restituire alcun valore viene utilizzata la parola void.
Mettiamo per esempio che volessimo creare un metodo che fa qualche calcolo e alla fine dovrà uscirne come valore un numero intero. Dovremmo scrivere la parola int come valore di ritorno.
Facciamo un esempio pratico con le stringhe, creiamo un metodo chiamato saluto che "lavori" e poi restituisca una stringa:
using System;

class Evviva
{

static string saluto() {

string pippo = "Benvenuti ";
string paperino = "su questa guida";

string stringa_uscita = string.Concat(pippo + paperino);

return stringa_uscita;
}
static void Main()
{
Console.WriteLine(saluto());
}
}

In qualunque punto del codice scriveremo saluto(); sarà come se scrivessimo la stringa che restituisce il metodo saluto.
Infatti, appena avviata l'applicazione verrà eseguito Main in cui si trova il solito metodo WriteLine che farà la solita cosa di stampare su schermo. Ma quando andrà a leggere cosa vogliamo stampare su schermo troverà un metodo e lo andrà ad eseguire. Il metodo saluto unisce le due stringhe e mette in uscita il risultato ottenuto(return stringa_uscita;) .
La parola return definisce la variabile d'uscita di un metodo e deve essere sempre presente se il tipo-di-ritorno è diverso da void.

nome-metodo. Rappresenta il nome del metodo che, come abbiamo visto, può essere un nome di nostra fantasia ma sempre univoco, ovvero, nessun altro metodo o variabile si potrà chiamare nello stesso modo.

lista parametri (opzionale). A volte, come vedremo in seguito, un metodo può avere bisogno di elaborare dei valori che servono al suo corretto funzionamento ed andranno dunque "spediti" al metodo come parametri. Se sarà necessario più di un parametro, essi andranno divisi con una virgola.

Nota: Apriamo una parentesi che ci riporta un passo indietro.
Anticipiamo subito che, anche le classi potranno ricevere dei parametri. Esattamente nello stessa maniera dei metodi. Questo perchè, quando andremo a creare un oggetto di una determinata classe, se vorremo che quell'oggetto sia diverso da altri della stessa classe, dovremo inviargli variabili diverse.
Prendiamo l'esempio della "palla" vista all'inizio (quando abbiamo parlato delle classi, nella lezione 3 ). Dicevamo che:

La palla ha le sue caratteristiche, il peso, il colore, il materiale, ecc.. che sarebbero le sue variabili. Ed ha i suoi "metodi" cioè i suoi modi di interagire con l'esterno, tipo il rimbalzo, la velocità con cui accelera se calciata..
Tali metodi dipendono dalle variabili di cui sopra, se per esempio il peso della palla è di 50 grammi, il metodo di rimbalzo produrrà determinati movimenti.
Se il suo peso, invece di 50 grammi fosse di 20 grammi, il rimbalzo, così come la velocità dopo un calcio, sarebbero diversi.
Dunque, se volessimo creare un'altra palla, con caratteristiche diverse da quelle di prima, dovremo creare un nuovo oggetto della " classe palla" e dargli delle variabili differenti da quelle di prima. In seguito le variabili che invieremo alle classi le chiameremo parametri.

Se per esempio avessimo voluto usare una nuovo oggetto della classe Evviva, avremmo dovuto inizializzare un nuovo oggetto di questa classe (con la parola chiave new che vedremo tra poco) in questo modo:

nuovo_oggetto_evviva = new Evvivia(parametro1,parametro2,...);

Ovviamente noi non abbiamo avuto bisogno ne di inizializzare un nuovo oggetto della classe Evviva, ne avremmo avuto il bisogno di inviarle dei nuovi parametri perchè non necessari.

Queste considerazioni servono solo da anticipazione a quello che vedremo appena parleremo di XNA dove, per usare una delle sue classi, dovremo inizializzarla, impostarla come se fosse una variabile e potremo inviarle dei valori come se fosse un metodo.

Torniamo al discorso sui metodi. Ora, avendo queste nuove conoscenze sui metodi, possiamo analizzare il solito metodo Main che ha:

modificatore di accesso:static;
non ritorna aclun valore, quindi:void;
ha un nome univoco: Main;
non ha parametri di ingresso: () .
Ci siamo? Posso capire che questa lezione sia stata un po' complicata rispetto alle altre ma vi assicuro che facendo le prime prove con XNA non avrete più dubbi.
Un'ultima lezione sugli operatori ( +, = ecc.. ) e poi passeremo all'agogniate classi di XNA.