[OT] A,B,C#... Guida alla Programmazione

[Capux]

Al fine di poter consentire a tutti di avere un minimo di infarinatura di programmazione per poter avere le basi per usare lo Script Editor, il Mission Director o simili posto qui una semplice ma spero esauriente guida di come poter preparare programmi con il linguaggio C#. Purtroppo è solo per Windows (mi dispiace per gli utenti della Mac o della Linux ). In questo modo spero di poter affacciare altre persone allo scripting e al modding e alla programmazione in generale.

Capux
Capurr & Pietrolsonn Shipbuilding Corporation A.I. Software Ltd., Freedom's Reach, X-Universe


A,B,C#... PROGRAMMARE IN MODO SEMPLICE E VELOCE
Guida in riferimento a Windows XP



CAPITOLO 1: COSA SERVE PER USARE C#?

La programmazione in C# non richiede particolari programmi. E’ più che sufficiente avere installato Windows XP, Vista o Seven con:
XP --> Service Pack 2 o superiore
Vista e Seven --> Service Pack 1 anche perchè non ce ne sono altri
Serve poi blocco note, oppure wordpad, o se si vuole essere professionali NotePad++ che è gratis (ma nn so dove pescarvelo purtroppo)

Ora se avete XP andate su: C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727
dovreste trovare tra i vari file uno che si chiama csc.exe.
se avete la cartella v3.0 o v3.5, potete usare quella: csc c'è anche li, e più aggiornato
se avete Vista verificate se è uguale... purtroppo nn ho mai dato un occhio a questo particolare
è importante che quando darete il comando path sulla console dei comandi ci sia l'indirizzo di questa cartella, che sia la 2.0.50727 o 3.0 o 3.5 (v. Cap 2)



CAPITOLO 2: SALVARE E COMPILARE IL PROGRAMMA
Allora, prima di imparare a scrivere il programma ecco cosa fare per compilarlo, ossia creare da blocco note un piccolo file .exe :
Salvate il file di blocco note su cui avete scritto il programma con estensione .cs (file, salva con nome, e scrivete tipo ciao.cs anzichè .txt)

1. Apriamo la console dei comandi: Start > Esegui > Cmd, o procedura analoga per vista
2. Lanciamo il comando Path C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727
3. Digitate cd + l’indirizzo del file da compilare
4. Scrivete “csc nome_file.cs

Se tutto è andato bene, digitate nome_file.exe : apparirà il programma creato. Potrete anche lanciarlo voi in qualunque momento facendoci sopra doppio click. Esistono altre opzioni per il compilatore, ma per il momento non le useremo.

[ external image ]

[ external image ]

[ external image ]

OPZIONI DEL COMPLATORE CSC.EXE
[ external image ]
[ external image ]


CAPITOLO 3: IL NOSTRO PRIMISSIMO PROGRAMMA, CIAO MONDO
ok, è ora di iniziare sul serio
scrivete queste cose su blocco note, poi vi dirò cosa vogliono dire:

Code: Select all

using System;             						
class ciao
{
               static void Main()
               {
                       Console.WriteLine("Hello, World!");
                       Console.ReadLine();
               }
}

ora salviamo e compiliamo come spiegato nel capitolo 2.
lanciamo il programma (troverete l'exe nella cartella del file .cs) e vi
dovrebbe uscire fuori una schermata simile alla precedente, ma con scritto sopra "Hello World!":

[ external image ]

>COSA ABBIAMO SCRITTO???

• C# è un linguaggio che fa distinzione tra maiuscole e minuscole
• using: parola chiave di C#,serve a dichiarare in quale namespace ricercare le classi con cui lavorare;
• class: altra parola chiave di C#, identifica una classe di nomi in un blocco di codice (si può dare qualunque nome alla classe)
• static void Main() richiama il metodo base di C#, il metodo Main() (Necessario per ogni applicazione). static indica che è un metodo -statico e void che non prevede parametri di ritorno (vedremo in seguito il significato di queste istruzioni).
• -Console.WriteLine() richiama il metodo WriteLine() della classe System.Console, che permette di scrivere sulla console; il metodo analogo di lettura è ReadLine();
• C# è un codice con all’interno la priorità degli operandi e l’associatività degli operatori, ma essendo inglese, richiede il punto e non la virgola nei valori decimali: 9,345  9.345

CAPITOLO 4: CONFLITTI DI NOMI
E’ molto importante evitare, all’interno del programma o di uno stesso blocco di codice (vedi pagine seguenti), di chiamare due stessi oggetti (tipi, costanti, metodi, ecc...) con lo stesso nome, onde evitare un possibile conflitto di nomi. Nel caso si verificasse un conflitto, il programma non verrebbe compilato. Nel caso i due “Nomi” siano all’interno di due blocchi di codice differenti che non interferiscono tra loro, è lecito dargli lo stesso nome. I nomi degli oggetti vengono chiamati identificatori e possono essere composti sia da simboli che lettere che numeri, a patto che inizino per lettera o con l’Underscore (_) o con la @ e che non contengano spazi. E’ proibito usare come identificatori le parole chiave di C# (vedi tabella), a meno che non vengano prcedute dalla @ (creando il cosiddetto carattere Verbatim). Tale ultima procedura è comunque vivamente sconsigliata. Sono validi anche i Caratteri Unicode ed è molto importante sapere che C# fa differenza tra maiuscole e minuscole, per cui i seguenti identificatori sono tutti validi e ben distinti:

@class
_034
Gnagna
\u005fIdentificatore
Briba
@4abcd
GNAGNA
Mio_Lavoro

Code: Select all

{ 
          tring tmp = “Paolo”;      /* conflitto di 
          int tmp = 4;		        nomi */       
 }

Per essere sicuri di evitare conflitti di nomi, è bene avere a mente il concetto di campo della variabile e di blocco di codice. Un blocco di codice è un’area del programma delimitata da due parentesi graffe ( { = inizio blocco } = fine blocco ). Può essere che all’interno di un blocco vi sia però un altro blocco: in quel caso, le variabili o gli oggetti dichiarati nel precedente blocco saranno visibili e non sarà possibile dichiararne altri con lo stesso nome.

PAROLE CHIAVE DI C#
[ external image ]




CAPITOLO 5:SCRIVERE COMMENTI

Può tornare utile durante la scrittura del programma inserire commenti sul lavoro fatto, al fine di non perdersi tra le righe cercando dei particolari passaggi o per facilitare la comprensione del programma ad altri utenti o al creatore stesso. C# mette a disposizione due modi per scrivere commenti:
\\ Questo è un commento su una riga
\* Questo è un
commento
su tre righe *\
Nei precedenti frammenti di programma e nei successivi potrete trovare commenti scritti per facilitare la lettura del programma. Grazie a questi due metodi possiamo scrivere a fianco del codice senza rischiare di compromettere il nostro programma.



CAPITOLO 6: USO E REGOLE DEL ;

• Non mettere il punto e virgola dopo le parentesi graffe, siano esse aperte o chiuse.
• L’ultima istruzione di un blocco, (che precede dunque la parentesi graffa di chiusura), vuole un punto e virgola come tutte le altre.
• Non mettere il punto e virgola dopo una parola chiave di un costrutto (eccetto do {} while() )
• Non mettere il punto e virgola dopo il nome della classe;
• Non mettere il punto e virgola dopo la definizione del metodo Main().

Il punto e virgola deve seguire soltanto le istruzioni semplici, tra le quali:

• Dichiarazione di variabili
• Assegnazione di variabili;
• Invocazione di un metodo;
• Direttiva using;

CAPITOLO 7: IL METODO MAIN()

Il metodo Main() è il metodo di base di tutti i programmi in C#. Il Compilatore csc, al momento della compilazione, ricerca subito il metodo Main() per la compilazione. Nel caso vi siano più classi contenenti più metodi Main(), occorre indicare la classe contenente il metodo Main() di partenza con l’opportuna opzione del compilatore. Siccome siamo agli inizi, per ora il Main() è l’unico metodo che useremo.
Esistono vari modi per invocare il metodo Main():

• static void Main() {…}
• static void Main(string[] args) {…}
• static int Main() {…}
• static int Main(string[] args) {…}

Per il momento useremo solo il primo o il secondo modo e accenneremo solamente agli altri due metodi. Il primo metodo è il più facile di invocazione, e non prevede parametri di ritorno (parola chiave void) né argomenti. Il secondo ha un argomento in entrata (string[] args) e i restanti due sono uguali ai primi, solamente che restituiscono un valore int alla fine del programma.

CAPITOLO 8: LA CLASSE SYSTEM.CONSOLE

Prima di creare un altro programma, terminiamo il discorso dicendo due parole sulla classe Console, che abbiamo usato nel nostro primo programma e che useremo ancora. La classe console, come altre classi che vedremo in seguito, possiede delle determinate proprietà e metodi. Siccome avremo bisogno di utilizzare altri metodi, elenco qui di seguito i principali:

• Console.Clear --> Cancella quello che c'è scritto sulla console (Metodo Pubblico)
• Console.ReadLine --> Legge l'ultimo input di dati dalla console (Metodo Pubblico)
• Console.WriteLine --> Scrive sulla Console le cose comprese tra ” e “ o il valore di una variabile. (Metodo Pubblico)
• Console.Title --> Imposta il titolo della console (Proprietà)

CAPITOLO 9: USO DEL METODO CONSOLE.WRITELINE()

1. Il metodo WriteLine() scrive tutto ciò che è compreso tra le due “” comprese all’interno delle parentesi;
2. Il metodo WriteLine() può anche scrivere il valore di una variabile senza bisogno di convertirlo in stringa. E’ sufficiente scrivere il nome della variabile all’interno delle parentesi senza virgolette. Quindi, se si scrive WriteLine(“A”) sulla Console comparirà scritta la lettera A, se si scrive WriteLine(A) viene scritto invece il valore della variabile A.
3. Per scrivere all’interno di una frase il valore di una variabile ci sono due modi:
   a) Si scrive la prima parte della frase, si inserisce il nome della variabile tra due operatori + e poi si scrive il resto (ES: WriteLine(“Valore=” + b + “fine” ); )
   b) si include un segnaposto numerato incluso tra una { e una } nel punto dove si desidera scrivere la variabile e a fine frase, separati da virgole, si scrivono i nomi delle variabili da scrivere nel testo in ordine di segnaposto (ES: WriteLine(“Il valore di A è:{0} e di B è:{1}”,a,b); )
4. I segnaposto vanno da 0 a ∞

CAPITOLO 10: IL SECONDO (FINALMENTE) PROGRAMMA

Proviamo ora a creare un programma che calcoli l’area di un rettangolo. Avremo bisogno di 3 variabili (vedremo in seguito cosa sono e come si usano) che ci aiutino a costruire la formula per l’area (A=b*h). Quindi, scriveremo:

Code: Select all

using System;
class Rettangolo
{
	static void Main()							
          {
	          double b, h, x;		  \\ Creazione delle variabili
	          b = 4;  			  \\ Assegnazione Variabile base
	          h = 3; 			  \\ Assegnazione Variabile altezza
	          x = b*h; 			  \\ Viene calcolata l’area; Assegnazione Variabile Area
	         Console.WriteLine(“L’area è:{0}",x);	  \\ Scriviamo il risultato
	}
}

Nel programma appena scritto due variabili numeriche di tipo double e che rappresentano la base e l’altezza del rettangolo vengono moltiplicate tra loro per otttenere il valore della terza variabile double, x, che rappresenta l’area del rettangolo. Ma cosa sono le variabili e i tipi ?

CAPITOLO 11: VARIABILI
Nella pagina precedente abbiamo parlato delle variabili. Ma cosa sono? Le variabili sono delle zone di memoria rappresentate da degli identificatori e da un tipo che ne classifica le funzionalità e le relazioni con altri elementi. Una variabile è rappresentata da un dato (di tipo espresso nella dichiarazione) che può cambiare o essere copiato o essere usato in operazioni matematiche durante il corso del programma. Per poter essere utilizzata, una variabile deve essere creata seguendo la seguente sintassi:

nomeTipo nomeVariabile;
Esempio: int A;
string Nome;

Dopo essere stata creata occorre assegnare un valore alla variabile, seguendo la seguente sintassi:

nomeVariabile = Valore;
Esempio: A = 4;
Nome = “Pietro”;

Si può anche assegnare il valore di una variabile durante la dichiarazione stessa. E’ sufficiente utilizzare la seguente sintassi:

nomeTipo nomeVariabile = Valore;
Esempio: bool Flag = true;
double x = 15;

Ricordiamo però le regole del blocco di codice e del campo di una variabile: se vogliamo quindi che una variabile si possa utilizzare in tutto il programma, dobbiamo dichiararla subito dopo l’invocazione del metodo Main(), anche se non la utilizzeremo subito. Inoltre, non è necessario creare ogni volta un variabile per riga, ma è possibile crearne molte insieme a patto che siano dello stesso tipo:

nomeTipo nomeVariabile1= valore, nomeVariabilen = valore;
nomeTipo nomeVariabile1, nomeVariabile2 ,nomeVariabilen;
Esempio: int x, a, b;
int x = 4, b = 5, g = 6;

Esiste anche l’assegnazione composta di valori ad una variabile:

nomeVariabile op= espressione
Esempio: x=x+1 >Diventa> x += 1


Come già detto, un tipo è una parola chiave che contraddistingue determinate aree di memoria in base al loro utilizzo, alla loro grandezza, alla loro precisione, etc... . Dando un’occhiata alle tabelle delle prossime pagine, potremo notare una grande varietà di tipi. Perché? Non sarebbe sufficiente avere un solo tipo numerico e uno solo alfanumerico? Si’, sarebbe sufficiente, ma anche molto inefficiente. Questo perché ogni tipo risponde a determinate esigenze, che non sarebbero soddisfabili in tutto e per tutto da un solo tipo. Per esempio, se volessimo contare il numero di persone presenti in una stanza, useremmo solo numeri interi, in quanto non ci può essere solo “mezza” persona. Allora, per evitare errori, useremo un tipo che accetta solo numeri interi e non anche decimali. Al contrario, se volessimo segnare la temperatura di oggi, non potremmo usare un intero, in quanto la temperatura può variare molto e per evitare imprecisioni non possiamo limitarci a esprimerla con un numero intero, ma dovremo usare anche decimali. Oppure, se volessimo calcolare un valore di tempo, come i secondi, useremmo un tipo intero che non accetta segni ma che sia espresso in valore assoluto, in quanto il tempo è solo positivo e non può essere rappresentato da numeri negativi.

[ external image ]

[ external image ]

Ci sono dei tipi che hanno funzioni di assegnazione o di scrittura sulla console diverse dagli altri: il double,il string, il char e il bool.

• Nel tipo string l’assegnazione di una frase a una variabile deve essere contenuta all’interno di due virgolette (”). Esempio: string A = “Paolo”;
• Nel tipo double la rappresentazione di un numero molto grande sulla console viene espressa in notazione scientifica. Esempio: 100000000 = 1E+08
• Nel tipo bool possono essere assegnati solo due valori: true (vero) e false (falso)
• Il tipo char accetta solo 1 carattere Unicode.

CAPITOLO 13: CONVERSIONI E COMPATIBILITA' TRA TIPI
Durante la scrittura di un programma ci può essere la necessità di convertire un tipo in un altro. Questa conversione può essere effettuata in cinque modi:

1) Si copiano le due variabili se è presente tra di esse una conversione implicita
Esempio: int Prova = 10 double A = Prova

2) Si effettua una conversione esplicita utilizzando gli opportuni metodi della classe System.Convert, con una possibile perdita di informazioni da un tipo all’altro.
Esempio: se si converte un valore decimal a un valore int, se sono presenti decimali nel decimal verranno troncati e nel valore int rimarrà solo l’intero
Sintassi: nomeVariabile = Convert.nomeMetodo(nomeOggettoDaConvertire) Esempio: double A; string Numero = Convert.ToString(A);

3) Si effettua una conversione esplicita tramite un Cast, con una possibile perdita di informazioni da un tipo all’altro. La conversione deve essere lecita, o il compilatore non accetterà il cast sollevando un’eccezione System.InvalidCastException (vedremo in seguito cosa sono le eccezioni).

Sintassi: nomeVariabile = (tipoVariabile)nomeVariabiledaConvertire
Esempio: double A; string Numero = (string)A;

4) Attraverso il metodo Boxing/Unboxing, che risulta però meno utile rispetto agli altri tre. Il processo di boxing consente di trasformare un valore numerico in un oggetto Object (Che come si legge nella tabella a pag. 24, è la classe base di tutti i tipi) per poi ritrasformarlo in un altro tipo. Il processo di boxing è però perlopiù usato per poter passare dei valori da una classe o da una struct all’altra, o anche da un blocco all’altro, se necessario, in quanto i tipi normali identificano parti della memoria stack (quella che risente dei blocchi di codice) mentre gli Object risiedono sulla memoria heap (quella che include tutto il programma). L’operazione, se non è lecita, solleverà un’eccezione System.InvalidCastException (vedremo in seguito cosa sono le eccezioni).
l’operazione di boxing/unboxing viene svolta così:

Sintassi Boxing: nomeObject = variabileDaBoxare
Esempio:
int i = 423; Object box = i;

Sintassi Unboxing: nomeVaribile =(tipoVariabile)nomeObject
Esempio:
int i = (int)box;

5) Utilizzando l’operatore as. L’operatore as consente di ottenere un oggetto tipizzato da un altro oggetto. Vedremo in seguito l’utilizzo di questo operatore, che non può essere utilizzato sui tipi di valore ma solo su quelli di riferimento (vedi tabella tipi).

ATTENZIONE: La conversione forzata tra tipi molto diversi (esempio: da string a int) può causare risultati inaspettati. Inoltre occorre evitare di convertire numeri troppo grandi in tipi che non li supportano (vedi intervallo dei tipi pag. 25). Anche in questo caso possono esserci risultati inaspettati.

[ external image ]

CAPITOLO 14: CLASSE SYSTEM.CONVERT

Ecco un’altra classe molto utile: la classe System.Convert. Questa classe non ha proprietà ma solo metodi di conversione, i quali sono elencati (i principali) qua sotto e possono generare un’eccezione System.InvalidCastException.

[ external image ]


CAPITOLO 15: OPERATORI
Nel programma che abbiamo scritto prima abbiamo usato degli operatori matematici per svolgere le operazioni. Per saperne di più, qui vi è una tabella con scritti tutti gli operatori e le loro precedenze.

[ external image ]
[ external image ]
[ external image ]
[ external image ]

E’ molto importante, oltre a sapere l’utilizzo degli operatori, conoscere anche la loro associatività e la loro precedenza, e, nel caso degli operatori logici bitwise, anche le tabelle di verità.
Gli operatori hanno una loro precedenza, in quanto in un’espressione vi possono essere numerosi operatori. Ecco una breve tabella che indica le precedenze degli operatori:

[ external image ]

Se nell’espressione vi sono operatori aventi tutti la stessa precedenza, entra in gioco l’associatività degli operatori.
Tutti gli operatori tranne quelli di assegnazione e ternari sono associativi da sinistra: x+y+z  (x+y)+z
Gli operatori di assegnazione e ternari sono associativi da destra:
x=y=z --> x=(y=z)

Gli operatori di tipo consentono di effettuare delle operazioni fra tipi.

L’operatore typeof tipizza un oggetto System.Type in un tipo scelto, con un’operazione molto simile al cast.
Sintassi: Type Nome = typeof(string)

L’operatore is confronta i tipi di due variabili e restituisce un valore booleano true nel caso siano dello steso tipo, false in caso contrario. Questo operatore viene spesso usato nel costrutto if() o if()else
Sinatssi: Nome is Nome

L’operatore as è utilizzabile solo nei tipi di valore converte un tipo in un altro. Qualora questa conversione non fosse possibile, viene restituito il valore null.
Sintassi: Nome as Nome

L’operatore new() serve per creare oggetti per i windows Form, Array, ma anche classi e istanze definite da noi stessi. Lo utilizzeremo solo in alcuni ambiti, ma è importante conoscerlo e non bisogna sminuirne l’importanza.

Noi, almeno per il momento, non utilizzeremo quasi mai questi quattro operatori se non in date circostanze.

CAPITOLO 16: COSTANTI
Le costanti sono variabili che mantengo immutato il loro valore per tutta la durata del programma e che non è possibile modificare. Le costanti devono essere dichiarate secondo la sintassi delle variabili, preceduta dalla parola chiave const e con assegnazione immediata del valore:
Sintassi: const nomeTipo nomeVariabile = valoreVariabile;
Esempio: const float PiGreco = 3.14152;
const string PrimoMese = “Gennaio”;

CAPITOLO 17: LITERAL
Un Literal è un qualunque valore numerico di un tipo. Ad esempio, 10 è un Literal di tipo int. Solitamente, il programma riconosce da se il tipo di Literal e lo abbina correttamente al tipo, ma ci sono casi in cui occorre risolvere alcune ambiguità. Per esempio, con 10 si può indicare un valore int, ma ache un decimal o un double. Per questo, a volte è necessario utilizzare dei suffissi o dei prefissi per aiutare il compilatore. Nelle dichiarazioni normali non è necessario, ma per tipi simili è obbligatori: float numero = 3.456f in quanto il compilatore considera il valore a virgola mobile come double di default.
I Literal utilizzabili sono i seguenti: f o F per il float, d o D per il double, l o L per il long, u o U un valore senza segno. la U può essere utilizzata anche in combinazione con la L (UL o LU) per indicare un ulong.

CAPITOLO 18: USIAMO I NUOVI ELEMENTI
Proviamo ora a scrivere un programma che calcoli l’attrazione reciproca tra due corpi data la massa dei due oggetti e la costante distanza tra loro, sapendo che F = G(m1x m2)/r2, dove G = Costante di Gravitazione Universale, m1 ed m2 le masse dei corpi e r la distanza fra i due corpi.

Code: Select all

using System;
class Attrazione_di_Gravità
{
	static void Main()							  	{
	const float G = 6.673E-11f;
 	double m1, m2, r, F;
	string tmp;
	Console.Clear();
	Console.WriteLine("Inserire la massa del primo corpo:");
	tmp = Console.ReadLine();
	m1 = Convert.ToDouble(tmp);
	Console.WriteLine("Inserire la massa del secondo corpo:");
	tmp = Console.ReadLine();
	m2 = Convert.ToDouble(tmp);
	Console.WriteLine("Inserire la distanza tra i due corpi:");
	tmp = Console.ReadLine();
	r = Convert.ToDouble(tmp); 
	F = G * (m1 * m2)/ Math.Pow(r , 2);
	Console.WriteLine("La forza di attrazione tra i due corpi è:{0}", F);
	}
}

CAPITOLO 19: LA CLASSE SYSTEM.MATH
Nel programma precedente, per elevare a potenza r, abbiamo usato un particolare metodo della classe System.Math, una classe che ci consente di poter utilizzare dei metodi specifici per fare complessi calcoli matematici. I numeri indicano gli overload.

[ external image ]

CAPITOLO 20: ISTRUZIONI E CICLI
Dopo che sappiamo tutto questo, perché non creare un programma che ci consenta di scegliere, per esempio, di quale poligono calcolare area e perimetro oppure di calcolare solo l’area o solo il perimetro?
a questo proposito, C# mette a disposizione delle strutture che ci permettono di scegliere o di ripetere delle operazioni: i cicli.
I cicli si dividono in molte categorie.

CAPITOLO 21: COSTRUTTO IF()ELSE
Il costrutto if()else permette di valutare una condizione (espressa tra le parentesi) e, nel caso sia vera, di eseguire un blocco di codice successivo. Se la condizione non è vera e vi è else seguito da un blocco di codice, viene svolto quel blocco di codice.
Nel caso dopo l’if o l’else vi debba essere più di una istruzione, è sufficiente includere le altre istruzioni in un blocco di codice {}. SI possono anche concatenare più else tra loro. E’ anche possibile utilizzare l’if() senza l’else. Nel caso la condizione è vera, viene svolto il blocco di codice seguente, se è falsa continua eseguendo l’istruzione successiva al costrutto. E’ importante, nella scrittura delle condizioni, sia if() o If()else, utilizzare operatori booleani: == (Uguale) != (Diverso) && (e) || (o)
Esempio: if( A == 1 && B != 1 || c ==3)

[ external image ]
[ external image ]

SINTASSI:

Code: Select all

if(condizione)
{
//istruzioni
}
else
{
//istruzioni
}

CAPITOLO 22: COSTRUTTO WHILE()
Il costrutto while() è un ciclo che si ripete finchè è vera una determinata condizione; quando questa diventa falsa, il ciclo termina. Viene valutata una condizione espressa tra le parentesi dopo il while, e , se è vera, allora viene eseguito il blocco di codice successivo. Quindi Il ciclo valuta la condizione nuovamente. Se è vera ri-esegue il Blocco, se è falsa esce. il ciclo termina quando la condizione diventa falsa. Come per l’if()else, se vi è più di un’istruzione la si può includere tra {}. Come per il costrutto if()else, la condizione deve essere booleana.

[ external image ]

SINTASSI

Code: Select all

while(condizione)
{
//istruzioni
}

CAPITOLO 23: COSTRUTTO FOR
Il costrutto iterativo for() ripete un blocco di codice se una condizione è vera e modifica secondo i parametri inseriti la condizione finchè non diventa falsa.
il costrutto for() può essere espresso sintetizzato così: for(Variabile; Condizione, incremento). Si noti che nell’incremento si possono usare sia gli operatori di incremento e di decremento (suffissi o postfissi) che le assegnazioni composte o addizzioni/sottrazioni di espressioni (anche lunghe). Se l’inizializzazione viene completata durante il codice che precede il ciclo, si può omettere nel ciclo stesso, così come l’incremento se vi è già all’interno del ciclo.

[ external image ]

SINTASSI

Code: Select all

for(inizializzazione(opz); condizione; incremento/decremento(opz)
{
//istruzioni
}

CAPITOLO 24: COSTRUTTO DO()WHILE()
Il costrutto do()while è molto simile al while. Nel costrutto do()while, il blocco dopo il do() viene eseguito finchè la condizione posta dal while() è vera. La differenza rispetto al ciclo while() è che il blocco di codice dopo il do() viene eseguito almeno una volta, in quanto solo dopo essere stato eseguito quel blocco viene valutata la condizione. Non si deve quindi usare in programmi con cicli che richiedono prima una verifica della condizione e poi il ciclo. Inoltre, il do()while() è l’unico tra i costrutti che richiede il ; dopo le parentesi tonde () della condizione while.

[ external image ]

SINTASSI

Code: Select all

do
{
//istruzioni
}
while(condizione);

CAPITOLO 25: COSTRUTTO FOREACH
Il costrutto foreach() è un costrutto simile al for() ma viene utilizzato per applicare una medesima condizione a tutti gli elementi di una collezione Array (vedremo tra poco a cosa sono e a che cosa servono). All’interno delle parentesi tonde viene creata una variabile nascosta che punta agli oggetti della collezione. Il ciclo scorre tutti gli oggetti della collezione e termina quando sono finiti gli elementi. Il tipo della variabile deve essere analogo a quello dell’Array, non può venirne modificato il valore ed è limitata al ciclo stesso. La variabile nascosta deve essere dichiarata nelle () e deve essere seguita dalla parola in e dal nome della collezione.

[ external image ]

SINTASSI

Code: Select all

foreach(tipo Nomevariabile in NomeCollezione)
{
//istruzioni
}

CAPITOLO 26: COSTRUTTO SWITCH
Il costrutto switch() è un costrutto di selezione simile all’if(). Nel costrutto switch() viene confrontata una variabile string con i vari casi a disposizione del ciclo. Se la stringa corrisponde a quel caso, allora viene eseguita una determinata operazione, se non vi è una corrispondenza viene eseguita un’operazione di default (non obbligatoria). La scelta multipla dello switch() deve essere annunciata da un’etichetta case e dal nome del caso.
Possono esserci infiniti casi;
Possono esserci infinite istruzioni tra i : dopo l’etichetta case e il break;
Tutte le istruzioni devono essere intervallate da un ;
Non ci possono essere due etichette case uguali;
Si può usare qualunque altra istruzione di salto al posto del break;

[ external image ]

SINTASSI

Code: Select all

switch(nomeVariabileStringa)   
{
case “1”: \\istruzioni; break;		         
case “2”: \\istruzioni; break;		         
case “n”: \\istruzioni; break;		         
default: \\istruzioni; break;	 	         
}

CAPITOLO 27: ISTRUZIONI BREAK, CONTINUE, GOTO
Queste istruzioni, dette di salto, possono essere utilizzate all’interno dei costrutti for(), foreach(), switch()(no l'istruzione continue), do()while() e while(). L’istruzione break fa uscire il programma dal costrutto passando all’operazione immediatamente successiva al ciclo interrotto. Abbiamo già visto l’utilizzo principale del break nel costrutto switch(). L’istruzione continue invece fa ricominciare l’iterazione del ciclo, indipendentemente dal punto in cui si trovi. L’istruzione goto, detta di salto incondizionato, sposta l’esecuzione del programma in un punto qualsiasi scelto dal programmatore che sia contrassegnato da un identificatore seguito da : .

CAPITOLO 28: ISTRUZIONE TRY-CATCH
L’istruzione try-catch serve a gestire le eccezioni. Un’eccezione si genera quando si verifica un evento che non può essere gestito dal computer. Un eccezione si genera quando viene passato un argomento non valido a un metodo, o quando un numero non rientra nell’intervallo di un tipo, o in moltri altri casi. Per evitare il blocco del programma, si usa il blocco try-catch. Si include la parte di codice che potrebbe generare un’eccezione nel blocco try e si scrive tra le tonde del catch il nome dell’eccezione da intercettare. Nel blocco di codice del catch vanno inserite le istruzioni da svolgere in caso venga generata l’eccezione specificata. Non c’è limite al numero di blocchi catch che possono seguire un try. Esiste anche l’istruzione try-finally e try-catch-finally, ma non ce ne occuperemo per ora.

SINTASSI

Code: Select all

try				       
{				        
\\ Istruzioni con possibile eccezione		        
}			              	        
catch (nomeEccezione)		        
{				         
\\ Istruzioni in caso di eccezione        	        
}

CAPITOLO 29: ISTRUZIONE THROW
L’istruzione throw viene spesso utilizzata per gestire meglio le eccezioni. L’istruzione throw consente di intercettare l’eccezione del try e di rigenerarla in una nuova eccezione che preferiamo da gestire. Se per esempio, per non appesantire un programma, non vogliamo usare intercettazioni particolari, rigeneriamo un’eccezione con un throw per essere sicuri che sia quella del giusto tipo.
NOTA: l’istruzione throw lancia sempre e comunque un’eccezione del tipo scelto. Se anche il try rileva un eccezione, riconverte quella del try, altrimenti ne crea una da sé. Puoi evitare di utilizzarla se non sei certo che si verifichi l’eccezione.

SINTASSI

Code: Select all

try				       
{				        
throw new Eccezione()		        
}			              	        
catch (Eccezione)	                       	        
{				         
\\ Istruzioni per Eccezione        	        	        
}

CAPITOLO 30: DIRETTIVA USING
La direttiva using consente di effettuare le due seguenti operazioni:
- Consentire l'utilizzo dei tipi in uno spazio dei nomi, per evitare di dover qualificare l'utilizzo di un tipo in tale spazio dei nomi.
- Creare un alias per uno spazio dei nomi.
La parola chiave using viene inoltre utilizzata per creare istruzioni using, che definiscono quando verrà eliminato un oggetto, e ce ne occuperemo tra poco.

Esempio: la direttiva using System.IO ci consente di scrivere StreamReader sr = new StreamReader(path) al posto di System.IO.StreamReader sr = new System.IO.StreamReader(path) consentendoci di abbreviare i metodi di richiamo.

SINTASSI

Code: Select all

using System.Nome1.Nome2.Nomen;
using Alias = SpaziodiNomi

CAPITOLO 31: ARRAY
Una variabile semplice può essere vista come un contenitore, etichettato da un nome, il cui contenuto rappresenta il valore della variabile.
Analogamente, un array unidimensionale, chiamato anche vettore, può essere visto come una fila di contenitori adiacenti, numerati (etichettati) a partire da zero, ognuno dei quali contiene un valore.
La fase della dichiarazione della variabile Array è separata dalla fase di creazione vera e propria dell’oggetto. La dichiarazione assume la seguente sintassi:
Tipo[ ] nomeVettore;
Esempio: int[ ] v;

La creazione assume la seguente sintassi:
nomeVettore = new tipo[numeroElementi];
Esempio: v = new int[5];
La creazione del vettore avviene tramite l’operatore new che produce l’allocazione in memoria del vettore.

Per fare riferimento a un elemento di un vettore occorre specificare sia il nome del vettore che l’indice dell’elemento:
nomeVettore[indiceElemento];
la sintassi fa uso dell’operatore accesso a elemento, rappresentato dalla coppia di parentesi quadre. indiceElemento deve essere di tipo int:
double x = 0; v[x] = 10;
L’esempio è sbagliato perché x deve essere di tipo int

Nel caso volessimo dichiarare e creare un vettore contemporaneamente, la dichiarazione assumerebbe la seguente sintassi:
Tipo[ ] nomeVettore = new tipo[numeroElementi];
Esempio: int[ ] v = new int[10];

Si possono assegnare valori ad un vettore durante la fase di creazione mediante la sintassi estesa:
Tipo[ ] nomeVettore = new tipo[numero-elementiopz] {val1, val2 …. Valn};
Esempio: int[] v = new int[10] {1,2,3,4,5,6,7,8,9,10};

o quella compatta:
Tipo[ ] nomeVettore = {val1, val2 …. Valn};
Esempio: int[] v = {1,2,3,4,5,6,7,8,9,10};

Tra matrici e vettori non esiste nessuna differenza concettuale o formale, poiché entrambi sono array. La differenza è nell’organizzazione dei dati:
Vettore: lista di elementi;
Matrice: tabella di elementi.
Come vedremo, le dimensioni di un Array sono indicate dal numero di virgole incluse tra le parentesi []. [] indica un vettore, [,] una matrice, [,,] un cubo, [,,,] un ipercubo e via dicendo...

Per avere l’accesso agli elementi di una matrice occorre rispettare la seguente sintassi:
nomeMatrice[indiceRiga, indiceColonna]
Esempio: M[1, 0] = 10; a = m[2, 3];

La sintassi della dichiarazione di una matrice è:
Tipo[,] nomeMatrice;
Esempio: int[,] m;

E per finire, per creare una matrice:
nomeMatrice = new tipo[numeroRighe, numeroColonne];
M = new int[5, 3];

Dichiarazione e creazione insieme:
Tipo[,] nomeMatrice = new Tipo[numeroRighe,numeroColonne]
Int[,] m = new int[5, 3];



CAPITOLO 32: METODI
Definire un metodo significa creare una nuova funzionalità della classe alla quale il metodo appartiene.
Essa assume la seguente forma generale:

modificatori(opz) tiporitorno nomemetodo (listaparametri opz)
{
istruzioni del metodo
}

Per ora considereremo una sola classe, quindi lo scheletro dei programmi con più metodi all'incirca sarà così:

Code: Select all

using System;
	class nome-classe
	{
		static void NomeMetodo1()
		{
			….
		}
		static void NomeMetodo2()
		{
			….
		}
		static void NomeMetodo3()
		{
			….
		}
		static void Main()
		{
			….
		}

	}

Il nostro prototipo di metodo,
modificatori(opz) tiporitorno nomemetodo (listaparametri opz)
specifica diversi parametri:

• I modificatori, opzionali, vedremo dopo il loro uso;
• Il tipo del valore ritornato dal metodo, o la parola chiave void se il metodo non produce alcun valore;
• Il nome del metodo;
• Tra parentesi, la lista di parametri che sono necessari al metodo per funzionare.

Per ora saranno considerati solo metodi che non producono valori di ritorno e non necessitano di parametri.
Il corpo definisce le istruzione che vengono eseguite all’atto dell’invocazione del metodo.
All’interno del corpo di un metodo sono ammesse dichiarazioni di variabili e qualsiasi istruzione esecutiva.
Non è ammesso invece definire un metodo all’interno di un altro metodo, né usare direttive using o definire classi.
Non esiste un ordine prestabilito nella definizione dei metodi.
Le istruzioni di invocazione dei metodi possono precedere la loro definizione.
L’invocazione di un metodo assume la seguente sintassi generale:
nome-metodo (lista-argomentiopz)
L’invocazione di un metodo può avvenire sia come elemento di un’espressione:
ES. Double x = Math.Sqrt(2) * 2;
sia come unico elemento dell’istruzione:
Console.WriteLine(“Salve, Mondo”);
L’uso più convenzionale che viene fatto dei metodi è quello di suddividere logicamente i compiti che il programma deve svolgere allo scopo di semplificarlo.
Può essere necessario usare una variabile in comune a diversi metodi: C# consente di dichiarare variabili a livello di classe chiamate campi classe o campi membro visibili (utilizzabili) in qualsiasi metodo della classe.
Il campo di azione di un campo membro è la stessa classe; si dice anche che il campo ha una visibilità di classe.
Esattamente come per i metodi, C# non impone nessun ordine particolare nella dichiarazione dei campo membro; né impone che la dichiarazione di un campo di classe debba precedere il suo uso, come è necessario per le variabili locali.
Ciò perché i campi membro vengono allocati in memoria e inizializzati prima che qualsiasi metodo della classe sia eseguito.
C# consente di dichiarare una variabile locale che ha lo stesso nome di un campo di classe?
(rullo di tamburi e silenzio stupefatto)...Sì
In che modo vengono interpretati i riferimenti a quella variabile?
Il campo d’azione locale “nasconde” sempre il campo d’azione di classe.
Per terminare in modo anticipato un metodo si può usare la seguente istruzione:
return espressionediritorno(opz);
Questa istruzione provoca l’uscita immediata dal corpo del metodo e il ritorno al mtodo chiamante.
Se l’istruzione è inserita all’interno del metodo Main() determina la fine immediata del programma.
Come si può intuire l’istruzione return, senza valori di ritorno, fa sempre parte di un costrutto di selezione. Ciò non rappresenta un requisito formale del linguaggio infatti se viene inserito prima dell’ultima istruzione queste non verranno mai eseguite e il compilatore segnala un avvertimento.
Non esiste alcun limite al numero di istruzioni return che possono comparire nel corpo di un metodo.
Per realizzare metodi che siano il più possibile indipendenti gli uni dagli altri bisogna:
a) Ridurre al minimo il numero di dati condivisi
b) Il funzionamento del metodo dipenda dal numero minimo di presupposti possibile.
Per applicare fino in fondo queste regole bisogna che i metodi producano valori di ritorno e accettano argomenti.
Il prototipo di un metodo che definisce dei parametri assume la seguente sintassi:
static void nome-metodo (lista-parametri)
Dove lista-parametri è definita nel seguente modo:
tipo param1, tipo param2, … tipo paramn
La lista degli argomenti specificati nell’invocazione deve corrispondere nel numero e nel tipo alla lista dei parametri definiti nel prototipo del metodo.
La corrispondenza richiesta tra gli argomenti specificati nell’invocazione di un metodo e i parametri definiti nel prototipo è la stessa che c’è tra l’espressione e la variabile in un’istruzione di assegnazione.
Infatti l’invocazione determina effettivamente l’assegnazione degli argomenti ai rispettivi parametri.
Tale assegnazione viene anche definita passaggio per valore degli argomenti, poiché al parametro viene appunto assegnato il valore dell’argomento.
I parametri definiti nel prototipo di un metodo sono a tutti gli effetti considerati delle variabili locali al metodo stesso, con due differenze fondamentali:
Nella dichiarazione di un parametro non può essere specificato un valore iniziale;
Un parametro di ingresso viene considerato dal linguaggio come inizialmente definito e quindi può essere utilizzato senza che sia stato oggetto di un’assegnazione.
Essendo i parametri considerati come delle variabili locali al metodo, on sono ammessi due o più parametri con lo stesso nome, come non sono ammessi parametri con lo stesso nome di variabili locali al metodo.
In moltissimi casi esiste la necessità di una comunicazione in entrambi le direzioni e ciò si ottiene con l’istruzione: return espressione-di-ritorno
In questo caso il prototipo del metodo deve definire un tipo di ritorno:
static tipo-ritorno nome-metodo (lista-parametriopz)
Ovunque, in una espressione, sia ammissibile un valore di tipo <T>, è anche ammissibile l’invocazione di un metodo il cui tipo di ritorno sia <T>.
Se un metodo ritorna un valore di norma deve essere invocato in una espressione. In realtà questo non rappresenta un requisito imposto dal linguaggio, il quale consente che il valore restituito da un metodo venga ignorato e che dunque il metodo stesso venga invocato come se definisse void come tipo di ritorno.
Esempio:
Console.ReadLine();
in questo caso il metodo ReadLine() non viene invocato per acquisire un valore ma al solo scopo di fermare l’esecuzione del programma fino a quando l’utente non prema il tasto invio.

CAPITOLO 34: WINDOWS FORM
Finalmente iniziamo a parlare dei noti windows Form. Inizierò col dire che è un tipo di programmazione molto più difficile che quella console, ma è molto più bella e interessante.

AVVISO: Se proprio non volete installare il .NET Framework 2.0.50727 osuccessivo, spegnete: non potete creare i windows form senza.

LA COMPILAZIONE DEL PROGRAMMA VA FATTA USANDO IL SEGUENTE METODO : csc /t:winexe nome-file.cs
(la trovate tra le opzioni del compilatore postate sopra)


L’applicazione Windows è caratterizzata principalmente da 4 elementi:

• L’interfaccia form, scheletro dell’applicazione;
• I controlli, oggetti che ricevono l’input dall’utente;
• Gli eventi, che si verificano in seguito a determinate azioni dei controlli;
• I metodi di gestione, che consentono di gestire gli eventi;

Nel creare il nostro programma, dovremo prima dichiarare tutti i controlli, le loro proprietà, gli eventuali eventi a loro assegnati e le variabili comuni a tutto il programma, quindi gestiremo gli eventi.

Code: Select all

using System;
using System.Windows.Forms;            \\Necessario per i controlli
using System.Drawing;
class NOMECLASSE: Form                    \\ :Form Indica la derivazione dalla classe Form
{			                \\Qui vanno dichiarati e creati i controlli
	public NOMECLASSE()
	{			\\Qui vanno gestiti gli eventi
	}
	public static void Main()	\\metodo Main()
	{
		Application.Run( new NOMECLASSE() );
	}
}

Se proviamo a compilare il programma qui sopra otteniamo questa finestra:
[ external image ]
Un windows form vuoto.

I Windows Form hanno come interaccia grafica un form. Il Form possiede eventi, proprietà pubbliche, proprietà protette, metodi pubblici e metodi protetti.
Ogni proprietà senza riferimenti a qualche controllo viene attribuita al form.
L’interfaccia grafica serve a contenere controlli che serviranno per ricevere o per inviare i dati all’utente. I controlli e tutte le loro proprietà vanno creati e dichiarati all’interno della classe. Prima del metodo Main() si devono quindi gestire gli eventi collegati ai controlli.
Application.Run() è un metodo della classe Application che fa funzionare il form. Il metodo finisce quando viene chiuso il form.

CAPITOLO 35: CONTROLLI
I controlli sono gli oggetti che ricevono input e inviano output all’utente tramite la gestione di determinati eventi, metodi e proprietà. Innanzitutto il controllo va dichiarato: tipo nomeControllo;
ESEMPIO Label lblA;
Il controllo va quindi creato attraverso l’operatore new():
nomeControllo = new tipo();
Esempio btnB = new Button()
Esiste anche la sintassi contratta:
tipo nomeControllo = new tipo();
Esempio Textbox txtA = new TextBox();
Per perfezionare invece l’aspetto estetico e altre proprietà del controllo si usa la sintassi:
nomeControllo.nomeProprietà = valore;
Esempio lblA.Text = “label A”;
Tutto questo, comunque, non rende il controllo né visibile né operativo. Per poterlo quindi utilizzare si deve aggiungerlo all’interfaccia grafica, invocando il metodo Add() della classe Controls:
Controls.Add(nomeControllo);
Esempio Controls.Add(btnB);
I nomi dei controlli devono presentare un suffisso che ne ricorda il tipo: lbl per Label; btn per Button; txt per TextBox eccetera.
ciò non è una imposizione del linguaggio quanto del buon senso, per ricordarsi il tipo di controllo senza fatica.

CAPITOLO 36: EVENTI
Un gestore di evento è un metodo che viene eseguito automaticamente in risposta all’evento al quale è attaccato. Sintassi:
void nomeMetodo (object sender, tipoInformazioniEvento e)

Il parametro sender che sta per mandante rappresenta un riferimento al controllo che ha sollevato l’evento.
il parametro e contiene le informazioni che qualificano ulteriormente l’evento. Comunque per il momento useremo la seguente forma:
void nomeMetodo (object sender, EventArgs e)

Una volta scritte le istruzioni dell’evento, non ci resta che associarlo ad un controllo:
nomeControllo.Evento = nomeControllo.Evento + new EventHandler(nomeMetodo);
oppure sinteticamente:
nomeControllo.Evento += new EventHandler(nomeMetodo);

CAPITOLO 37: MESSAGE BOX
La messageBox è un piccolo form invocabile con un solo metodo (che è l'unico che possiede la classe) che è il metodo MessageBox.Show();
possiede diverse implementazioni:

• MessageBox.Show(string text)
• MessageBox.Show(string text,string caption)
• MessageBox.Show(string text,string caption,MessageBoxButtons buttons)
• MessageBox.Show(string text,string caption,MessageBoxButtons buttons,MessageBoxIcon
  icon)
• MessageBox.Show(string text,string caption,MessageBoxButtons buttons,MessageBoxIcon
  icon,MessageBoxDefaultButton defaultButton)
• MessageBox.Show(string text,string caption,MessageBoxButtons buttons,MessageBoxIcon
  icon,MessageBoxDefaultButton defaultButton,MessageBoxOptions options)

La proprietà text indica il testo scritto nella MessageBox, la string Caption il titolo della MessageBox, i buttons (OK, OKCancel, AbortRetryIgnore, RetryCancel, YesNo, YesNoCancel ) i bottoni presenti sulla MessageBox, l'icon l'icona vicino alla MessageBox (Asterisk, Error, Exclamation, hand, Information, None, Question, Stop, Warning) e options le opzioni (utilizzate poco). Maggiri dettagli sono reperibili nella guida linkata nelle dispense aggiuntive.
Per ottenere la risposta del pulsante possiamo fare riferimento al seguente codice di esempio:

Code: Select all

DialogResult result=MessageBox.Show("Vuoi continuare?","Conferma",MessageBoxButtons.YesNo);
if(result==DialogResult.Yes)
{
MessageBox.Show("L'utente ha scelto di continuare");
}

I membri della classe enumerativa DialogResult sono: OK, Cancel, Abort, Retry, Yes, No, Ignore, None.


CAPITOLO 38: SALUTI
QUI SI CONCLUDE IL NOSTRO VIAGGIO. SE MAI QUALCUNO ARRIVERA' QUI IN FONDO E LEGGERA' QUESTE RIGHE, OTTIMO LAVORO
PER QUALUNQUE INCONGRUENZA, PROBLEMA O DUBBIO O ANHE SEMPLICE CURIOSITA, POTETE CONTATTARMI VIA PM o con una E-Mail a TheCapux93@hotmail.it. Sono anche sul Forum LCU per ogni evenienza.

DISPENSE AGGIUNTIVE
Alcune cose che vi torneranno utili

DISPENSE

Qui, nella cartella C#, potete trovare:
-Specifiche del linguaggio, dalla versione 1.2 di csc alla 3.0;
-Specifiche di alcune classi e namespace comuni;
-Guide: quella di Antonio Pelleriti consigliata a chi vuole andare oltre...

COMPITI PER CHI NE HA VOGLIA
Se qualcuno vuole provare ad esercitarsi può iniziare con il svolgere questi semplici programmi, in ordine di difficoltà.

• Realizzare una applicazione console in linguaggio C# che consenta di inserire il nome dell' utente:
  se il nome inserito corrisponde al proprio
  visualizzi il messaggio “Ciao, <nomeutente>, felice di ritrovarti“,
  altrimenti visualizzi il messaggio “Ciao, <nomeutente>, non ti ho riconosciuto”.
• Realizzare una applicazione console in C# che consenta di simulare il funzionamento di una calcolatrice in grado di effettuare le 4 operazioni elementari tra due numeri reali.
  L’applicazione deve realizzare le seguenti funzioni tramite un menu di scelta:
  Inserimento dei due numeri
  Somma dei numeri inseriti
  Prodotto dei numeri inseriti
  Differenza dei numeri inseriti
  Divisione dei numeri inseriti
  L’applicazione deve rispettare i seguenti vincoli:
  Le singole operazioni possono essere selezionate e svolte solo se si sono prima inseriti i numeri
  Il valore 0 (zero) viene posto come termine del programma
• Realizzare una applicazione Windows in C# che svolga le funzioni di una semplice calcolatrice
  La form dovrà contenere 2 TextBox (per i numeri su cui svolgere le operazioni), 4 Button (per la esecuzione delle 4 operazioni, somma, sottrazione, prodotto, divisione) ed 1 Label (che conterrà il risultato).
  All’interno della gestione degli eventi dei bottoni , controllare che vi siano dati corretti ed eventualmente comunicare mediante opportune MessageBox la situazione di errore.
• Realizzare una applicazione Windows che posizionato un bottone al centro di una form con la scritta “Prova a cliccarmi”, giochi con l’utente impedendogli, per l’appunto di ciccare su di esso, spostando continuamente il bottone stesso in una posizione casuale della form sfruttando le proprietà Width e Height e gestendo l’evento MouseEnter.
  Devono essere rispettate, inoltre, le seguenti specifiche
  Nella barra del titolo della Form, deve essere visualizzato il numero dei tentativi che ha già effettuato l’utente
  Dopo 10 tentativi da parte dell’utente di cliccare sul bottone si deve far apparire una MessageBox che informa l’utente che ha perso ed il programma deve terminare.
  PS:
  Si ricorda che:
  Random Casuale = new Random();
  Crea un generatore di numeri casuale.
  E che
  Valore = Casuale.Next(max);
  assegna alla variabile Valore un numero causale compreso tra 0 e max

SOLUZIONI DEI COMPITI

ESERCIZIO 1

Spoiler

Show

using System;

class DatiAccesso
{
static void Main()
{
string nome;
Console.WriteLine("Immettere Cognome:");
nome = Console.ReadLine();
if (nome == "Capurro")
Console.WriteLine("Ciao " + nome + " ,felice di ritrovarti");
else
Console.WriteLine("Ciao " + nome + " ,non ti ho riconosciuto");
}
}

ESERCIZIO 2

Spoiler

Show

using System;

class test
{
static void Main()
{
double a2, b2, x, y, z, w;
string a1, b1, c="";
while ( c !="0")
{
Console.WriteLine( "Immettere il primo numero:");
a1 = Console.ReadLine();
a2 = Convert.ToDouble(a1);
Console.WriteLine( "Immettere il secondo numero:");
b1 = Console.ReadLine();
b2 = Convert.ToDouble(b1);
Console.WriteLine( "Scegliere l'operazione da eseguire:");
c = Console.ReadLine();
x = a2 + b2;
y = a2 - b2;
z = a2 * b2;
w = a2 / b2;

if ( c == "Somma" )
Console.WriteLine( "Risultato = " + x);
if ( c == "Differenza" )
Console.WriteLine( "Risultato = " + y);
if ( c == "Prodotto" )
Console.WriteLine( "Risultato = " + z);
if ( c == "Divisione" )
Console.WriteLine( "Risultato = " + w);

}

}

}

ESERCIZIO 3

Spoiler

Show

using System;
using System.Windows.Forms;
using System.Drawing;

class calcolo: Form
{
Label lblA;
Label lblB;
TextBox txtA;
TextBox txtB;
Button btnA;
Button btnB;
Button btnC;
Button btnD;
public calcolo()
{
Text="Windows Microfrost Offisse calculator 007";

lblA=new Label();
lblA.Text="Il risultato è: ";
lblA.Top=200;
lblA.Left=25;
Controls.Add(lblA);

lblB=new Label();
lblB.Text="Inserisci i numeri: ";
lblB.Top=25;
lblB.Left=100;
Controls.Add(lblB);

txtA=new TextBox();
txtA = new TextBox();
txtA.Top=50;
txtA.Left=25;
Controls.Add(txtA);

txtB = new TextBox();
txtB.Top = 50;
txtB.Left = 150;
Controls.Add(txtB);

btnA =new Button();
btnA.Text="Somma";
btnA.Top= 100;
btnA.Left=50;
Controls.Add(btnA);
btnA.Click += new EventHandler(btnA_Click);

btnB =new Button();
btnB.Text="Differenza";
btnB.Top= 100;
btnB.Left=150;
Controls.Add(btnB);
btnB.Click += new EventHandler(btnB_Click);

btnC =new Button();
btnC.Text="Prodotto";
btnC.Top= 125;
btnC.Left=50;
Controls.Add(btnC);
btnC.Click += new EventHandler(btnC_Click);

btnD =new Button();
btnD.Text="Divisione";
btnD.Top= 125;
btnD.Left=150;
Controls.Add(btnD);
btnD.Click += new EventHandler(btnD_Click);
}
void btnA_Click(object sender, EventArgs e)
{
double a = Convert.ToDouble(txtA.Text);
double b = Convert.ToDouble(txtB.Text);
double x;
x = a + b;
lblA.Text = "Il risultato è: " +x ;

}
void btnB_Click(object sender, EventArgs e)
{
double a = Convert.ToDouble(txtA.Text);
double b = Convert.ToDouble(txtB.Text);
double x;
x = a - b;
lblA.Text = "Il risultato è: " +x ;

}
void btnC_Click(object sender, EventArgs e)
{
double a = Convert.ToDouble(txtA.Text);
double b = Convert.ToDouble(txtB.Text);
double x;
x = a * b;
lblA.Text = "Il risultato è: " +x ;

}
void btnD_Click(object sender, EventArgs e)
{
double a = Convert.ToDouble(txtA.Text);
double b = Convert.ToDouble(txtB.Text);
double x;
x = a / b;
lblA.Text = "Il risultato è: " +x ;

}
public static void Main()
{
Application.Run( new calcolo() );
}
}

ESERCIZIO 4

Spoiler

Show

using System;
using System.Windows.Forms;
using System.Drawing;
class Prendimi: Form
{
Button btnA;
int A,L;
int Tent=0;
public Prendimi()
{
Text="Prendimi!";
btnA=new Button();
Controls.Add(btnA);
btnA.Text="Prova a cliccarmi";
btnA.Top=100;
btnA.Left=100;
btnA.Width=100;
btnA.MouseEnter += new EventHandler(btnA_MouseEnter);
btnA.Click += new EventHandler(btnA_Click);
}
void btnA_MouseEnter(object sender , EventArgs e)
{

if(Tent<=10)
{
Tent=Tent+1;
Random VA=new Random();
A=VA.Next(501);
btnA.Top=A;
Random VL=new Random();
L=VL.Next(501);
btnA.Left=L;
}

if(Tent>=10)
{
MessageBox.Show("Mi dispiace, hai perso! OK per giocare di nuovo", "Hai Perso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
Tent = 0;
}
}
void btnA_Click(object sender, EventArgs e)
{
MessageBox.Show("Complimenti, ce l'hai fatta in " + Tent + " tentativi", "Hai Vinto!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
Tent = 0;
}

public static void Main()
{
Application.Run(new Prendimi());
}
}

Se volete aggiungere qualcosa o avete dubbi o volete che corregga i vostri programmi, postate

[GVNN di Herron]

GRANDE CAPUX

[DannyDSC]

capux ti faccio i miei più sentiti ringraziamenti e complimenti. La tua guida oltre che utile è davvero ben scritta e dimostra un'ottimo contributo per la comunità

Grazie

[Capux]

e di che?
Appena posso ne preparo una per lo scripting di TC e X3R...
ammesso che la scuola non mi distrugga
@DannyD: Conosci qualche linguaggio diverso?
io mi fermo al C# e al php (poco), oltre a un poco di HTML e l'odioso Pascal...
@moderatori: forse alcune immagini sono un pò grandi, ma mi perdonate?

[-Dna-]

Iniziare da Java o C(++) con un simpatico IDE non era più facile?

@moderatori: forse alcune immagini sono un pò grandi, ma mi perdonate?

No. Le regole sono uguali per tutti, quindi o metti i link o ridimensioni le immagini sia in peso sia in dimensioni (640x480px per 50KB).

[Capux]

@-Dna-
640x480 lo sono tutte perchè sennò non riuscivo a metterle nella pagina, il peso non so... controllo, ma mi sembra ok anche quello, devo aver confuso con un altro forum, pardon
EDIT: c'era una fuori misura, corretta.

Iniziare da Java o C(++) con un simpatico IDE non era più facile?

... Mica hai l'IDE nello script editor del gioco... e poi così non servono chissà che programmi, blocco note e via ...

Potete benissimo usare l'IDE per C#, nessuno vi obbliga con blocco note...
Per programmare ad alto livello comunque consiglio Visual Studio 2008... Ma mano al portafogli, costa caro. Sennò un altro editor ma io mi trovo bene con quello...
Se volete preparo anche per Java ma mi fermo ai costrutti base... di più non conosco...