Capitolo 2
La sintassi del Compact Framework 2.0
In questo capitolo vedremo le parole chiave più usate e comuni da utilizzare nel linguaggio di programmazione Visual Basic 2005 e C# (si pronuncia c sharp),
2.1 Le variabili
Le variabili hanno una grande importanza nel linguaggio, esse permettono di allocare in memoria (ram) le informazioni che possiamo utilizzare nel programma, informazioni di tipo testo, numerico ecc. Queste informazioni vengono definite in base al tipo. I dati delle variabili possono essere modificati, di volta in volta, a seconda delle proprie esigenze; in base al tipo con cui viene creata, la variabile occuperà una certa dimensione nella memoria. Il compilatore (es. Visual Studio 2005), a seconda della definizione della variabile, interpreterà tale dato, evidenziando errori qualora l’assegnazione di un dato ad essa non fosse corretto. Per esempio, non possiamo assegnare un valore di tipo lettera ad una variabile dichiarata come intero; quando si dichiara una variabile il compilatore fa si che nella memoria questo dato venga riservato in un’area della ram, con un determinato nome e tipo. Di seguito viene riportata la tabella dei dati delle variabili.
Tabella dei dati
|
Tipo di dato C# / Vb.NEt
|
Tipo del .Net (CLR)
|
Allocazione in memoria
|
Intervallo di valori
|
|
Bool /Boolean
|
System.Boolean
|
4 byte
|
True e false
|
|
byte/Byte
|
System.Byte
|
1 byte
|
Da 0 a 255
|
|
Char/Char
|
System.Char
|
2 byte
|
Da 0 a 65535
|
|
DateTime/date
|
System.DateTime
|
8 byte
|
Dalla mezzanotte del 1° gennaio 0001 alle 23.59.59 del 31 dicembre
|
|
decimal/Decimal
|
System.Decimal
|
16byte
|
Da 0 a +/-79.228.162.514.264.337.593.543.950.335 (+/-7,9...E+28) † senza decimali; da 0 a +/-7,9228162514264337593543950335 con 28 posizioni decimali;
il numero più piccolo diverso da zero è +/-0,0000000000000000000000000001 (+/-1E-28)
|
|
double/ Double
|
System.Double
|
8 byte
|
Da -1,79769313486231570E+308 a -4,94065645841246544E-324 † per i valori negativi;
Da 4,94065645841246544E-324 a 1,79769313486231570E+308 † per i valori positivi
|
|
int /Integer
|
System.Int32
|
4 byte
|
Da -2.147.483.648 a 2.147.483.647 (con segno)
|
|
long/Long
|
System.Int64
|
8 byte
|
Da -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 (9,2...E+18 †) (con segno)
|
|
object/Object
|
System.Object(classe)
|
4 byte
|
In una variabile di tipo Object è possibile memorizzare qualsiasi tipo
|
|
sByte/ SByte
|
System.SByte
|
1 byte
|
Da -128 a 127 (con segno)
|
|
short/Short
|
System.Int16
|
2 byte
|
Da -32.768 a 32.767 (con segno)
|
|
/Single
|
System.Single
|
4 byte
|
Da -3,4028235E+38 a -1,401298E-45 per i valori negativi;
Da 1,401298E-45 a 3,4028235E+38 per i valori positivi
|
|
string/String
|
System.String(Classe)
|
10 byte + 2 * lunghezza stringa
|
Da 0 a circa 2 miliardi di caratteri Unicode
|
|
|
|
|
|
Per dichiarare una variabile in Visual Basic, si usa la parola chiave dim, seguita dal nome della variabile e dal tipo; mentre in c# si definisce prima il tipo e poi il nome della variabile con un punto è virgola che indica la fine dell’istruzione.
Oltre a dichiarare la variabile possiamo anche instanziarla con un valore tramite l’operatore =, o dichiarare più variabili dello stesso tipo.
Di seguito si riportano le dichiarazioni di variabili del linguaggio Visual Basic e C#:
Visual Basic:
'dichiaro la variabile di tipo testo
Dim strTesto As String
'dichiarazione ed impostazione del valore
Dim StrTesto2 As String = "ciao"
'dichiarazione di più variabili (può essere anche una) di tipo intero (integer)
Dim intVariabile, intvariabile2 As Integer
'dichiaro ed imposto la variabile di tipo booleano
Dim blnSiNo as Boolean = True
'dichiarazione di tipo short ed imposto il valore
Dim shrVariabile As Short = - 29000
'dichirazione di tipo byte ed imposto il valore
Dim bytVariabile As Byte = 240
'dichirazone di tipo long
Dim lngVariabile As Long = 643333333
'dichirazione di tipo double
Dim dblVariabile As Double = 12544
'dichiaraizone di tipo decimal
Dim dcmVAriabile As Decimal = 200.55D
'dichirazione di tipo data
Dim dttVariabile As Date = Now()
C#:
//dichiarazione di variabile di tipo stringa
string strTesto;
//dichiarazione di variabile ed impostazione del valore
string strtesto2 = "ciao";
//dichiarazione di più variabili (può essere anche una) di tipo intero (integer)
int intvariabile, intvariabile2;
//dichiaro ed imposto la variabile di tipo booleano
bool blnSiNo = true;
//dichiarazione di tipo short ed imposto il valore
short shrVariabile = - 29000;
//dichirazione di tipo byte ed imposto il valore
byte bytVariabile = 240;
// dichirazone di tipo long
long lngVariabile = 643333333;
//dichirazione di tipo double
double dblVariabile = 12544;
// dichiaraizone di tipo decimal
decimal dcmVAriabile = 200.55m;
//dichirazione di tipo data
DateTime dttVariabile = System.DateTime.Now;
Inoltre la dichiarazione delle variabili può essere multipla e mista, ossia su una sola riga si possono dichiarare più variabili di diverso tipo; di seguito si riporta un esempio:
Vb.Net
'dichiarazione multipla e mista
Dim StrTesto3 As String, IntIntero As Integer
C#
//dichiarazione multipla e mista
string strTesto3; int intIntero;
Il C#, a differenza del Visual Basic, è case sensitive; ossia è diverso scrivere un oggetto o variabile con la lettera maiuscola piuttosto che con la lettera minuscola; mentre per il linguaggio Visual Basic non ci sono differenze, per il C#, in questo modo è come se fossero due dichiarazioni diverse.
Per esempio,per il C#, è diverso dichiarare una variabile di tipo stringa con la lettera iniziale maiuscola, anziché che con la lettera iniziale minuscola; mentre per Visual Basic non ci sono differenze e quindi sarà un errore.
Vb.Net
Errore
'dichiaro una variabile con la prima iniziale maiuscola e con la seconda minuscola è un errore
Dim StrTesto As String = "Corso"
'il compilatore ci informa che già esiste una variabile dichiarata con lo stesso nome
Dim strTEsto As String = "Corso"
C#
Nessun errore
//dichiaro una variabile con la S maiscuola la prima volta e minuscola la seconda. Due variabili distinte
string StrTesto = "Corso";
//variabile che ha la stessa denominazione ma con la iniziale minuscola
string strTesto = "Corso";
In Visual Basic si hanno ulteriori disposizioni nella gestione delle variabili; per esempio si possono utilizzare i caratteri di identificatoritipo per dichiarare una variabile; tramite alcuni caratteri speciali si possono definire delle variabili di un determinato tipo, questi caratteri devono seguire il nome di tali variabili o costanti senza spazi o altri caratteri .
Di seguito si riportano degli esempi:
|
Carattere
|
Tipo
|
Esempio
|
|
%
|
Integer
|
Dim intero%
|
|
&
|
Long
|
Dim lngLong&
|
|
@
|
Decimal
|
Dim DcmDeciaml@
|
|
!
|
Single
|
Dim SngSingle!
|
|
#
|
Double
|
Dim DblDouble#
|
|
$
|
String
|
Dim StrString$
|
Sempre in Visual Basic, si può utilizzare l’istruzione Option Explicit, la quale obbliga la dichiarazione esplicita delle variabili; in questo modo il programma non sarà avviato, finché tutti gli oggetti non saranno stati dichiarati; in questo modo si evitano errori in fase di esecuzione (run-time). Per attivare tale funzionalità, inserire tale testo, seguito da on, in alto prima di ogni testo. Per impostarlo a tutti i progetti, anziché digitarlo, tramite le proprietà del progetto (dal menu progetto selezionare la voce proprietà) selezionare la voce laterale (lato sinistro) compila, e da li impostare tale opzione. Di seguito si riporta un esempio: nel primo caso con la parola on (abilitato) il compilatore ci informerà la mancata dichiarazione, mentre nel secondo caso (seguito da off, e quindi disabilitato) non verrà segnalato questo errore, ma in fase di esecuzione del programma verrà sollevato un errore.
'variabile senza averla dichiarata con on, sarà segnalato un errore e verrà bloccata la compilazione
strTesto = "Ciao"
'variabile senza averla dichiarata con off, non verrà segnalato tale errore.
strTesto = "Ciao"
Inoltre in Visual Basic.Net si ha la possibilità di utilizzare Option Strict; essa permette di verificare prima della compilazione se la conversione del tipo è corretta, per evitare perdite di dati; in questo modo si può evitare che vengano sollevate eccezioni (errori) a run-time, ossia quando il programma è in esecuzione. Per attivare tale opzione, dobbiamo inserire in testa al file, prima di ogni dichiarazione, tale parola seguita da on, ossia nel seguente modo Option Strict on. Con tale opzione, per esempio, non possiamo dichiarare una variabile di tipo intero ed assegnarle un valore di tipo stringa. Se invece non impostiamo tale parametro, impostando un valore di tipo stringa ad una variabile dichiarata come intero, verrà sollevata un’ eccezione solo quando il programma sarà in esecuzione in quel punto. Di seguito si riporta un esempio.
'dichiaro una variabile di tipo intero, se ho attivato option strict, verrà segnalato come errore, altrimenti no.
Dim intVAlore As Integer = "ciao"
‘Se option Strict è impostato su off, non si viene informati di tale errore, nel momento in cui è in esecuzione il programma, verrà generata un’ eccezione.
Dim intVAlore As Integer = "ciao"
2.2 Le costanti
Le costanti permettono di avere allocato in memoria un tipo di dato con una determinata informazione che non cambia; a differenza delle variabili, le costanti non permettono la modifica dell’informazione contenuta in esse, a differenza di quanto avviene con le variabili, il cui valore si può cambiare di volta in volta. Pertanto, una volta dichiarata una constante, non sarà più possibile modificarne il valore. I tipi per le costanti sono gli stessi tipi utilizzati per le variabili, ossia string, integer ecc. Per dichiarare una constante si utilizza la parola chiave const seguita dal tipo di constante, nome e valore. Di seguito si riporta qualche esempio, per altri tipi fare riferimento alla parte della variabili:
Vb.Net
'dichiaro una constante di tipo stringa
Const StrTesto As String = "Testo"
'dichiaro una constante di tipo intero
Const IntIntero As Integer = 31
'dichiaro una constante di tipo boolean
Const blnSiNo As Boolean = True
C#
//dichiarazione di una constante di tipo stringa
const string strTesto = "Ciao";
//dichiarazione di constante di tipo intero
const int IntIntero = 31;
//dichiaro ed imposto una constante di tipo booleano
const bool blnSiNo = true;
I commenti
I commenti permettono di inserire qualsiasi testo, senza che esso venga esaminato dal compilatore; con i commenti si esclude tale testo dalla compilazione del nostro programma; in questo modo il nostro ambiente di sviluppo non tiene conto di ciò che è scritto. È buona norma che ogni programmatore, o persona addetta alla creazione dei programmi, usi tale funzionalità per descrivere le varie fasi del programma; in questo modo si ha una facile interpretazione di ciò che si sta facendo, sia per noi che per altri. Di seguito si riporta un esempio per i due linguaggi. Per Visual Basic.Net si utilizza il simbolo del singolo apice ‘, mentre per il C# il seguente simbolo: //
Vb.Net
'testo per il commento
C#
//commento su una riga
Se invece il commento è su più righe:
/* commento
* su più righe
fine commento */
Operazioni sulle Variabili
Per le variabili, o altri oggetti, si possono utilizzare alcuni operatori; gli operatori permettono di concatenare delle stringe o fare operazioni matematiche. Di seguito si riportano degli esempi:
Vb.Net
Concatenare del testo simbolo &
‘dichirazione di variabile di tipo string
Dim StrTesto As String = "Corso "
‘Concatenare del testo
StrTesto = StrTesto & " di programmazione"
'il risultato sarà Corso di programmazione
Oppure abbreviato
‘dopo aver dichiarato la variabile
StrTesto &= " di programmazione"
Fare la somma tra due numeri tramite l’operatore +
'somma tra due numeri
Dim IntSomma As Integer = 3
'tramite il simbolo + eseguo l'addzione
IntSomma = IntSomma + 2
'il risultato sarà 5
'di seguito in modalità abbreviata
IntSomma += 2
Fare la sottrazione tra due numeri tramite l’operatore -
'Sottrazione tra due numeri
Dim IntSottrazione As Integer = 10
IntSottrazione = IntSottrazione - 2
'il risultato sarà 8
'di seguito in modalità abbreviata
IntSottrazione -= 2
Fare la moltiplicazione tra due numeri tramite l’operatore *
'moltiplicazione tra due numeri
Dim IntMoltiplica As Integer = 5
IntMoltiplica = IntMoltiplica * 5
'il risultato sarà 25
'di seguito si riporta in forma abbreviata
IntMoltiplica *= 5
Fare la divisione tra due numeri tramite l’operatore /
'divisone tra due numeri
Dim dblDivisone As Double = 10
dblDivisone = dblDivisone / 2
'il risultato sarà 5
'in forma abbreviata
dblDivisone /= 2
C#
Concatenare del testo tramite il simbolo +
//dichirazione della variabile
string StrTesto = "Corso ";
//concateno il testo
StrTesto = StrTesto + " di programmazione ";
//in forma abbreviata
StrTesto += " di programmazione";
Fare la somma tra due numeri tramite l’operatore +
//somma tra due numeri
int IntSomma = 3;
// tramite il simbolo + eseguo l'addzione
IntSomma = IntSomma + 2;
//il risultato sarà 5
//di seguito in modalità abbreviata
IntSomma += 2;
Fare la sottrazione tra due numeri tramite l’operatore -
//Sottrazione tra due numeri
int IntSottrazione = 10;
IntSottrazione = IntSottrazione - 2;
//il risultato sarà 8
//di seguito in modalità abbreviata
IntSottrazione -= 2;
Fare la moltiplicazione tra due numeri tramite l’operatore *
//moltiplicazione tra due numeri
int IntMoltiplica = 5;
IntMoltiplica = IntMoltiplica * 5;
//il risultato sarà 25
//di seguito si riporta in forma abbreviata
IntMoltiplica *= 5;
Fare la divisione tra due numeri tramite l’operatore /
//divisone tra due numeri
double dblDivisone = 10;
dblDivisone = dblDivisone / 2;
//il risultato sarà 5
//in forma abbreviata
dblDivisone /= 2;
2.3 Le strutture
Le strutture sono dei tipi definiti dall’utente e sono simili alle classi, con la differenza che non possono essere ereditate ed il loro utilizzo e dichiarazione sono diversi. Le strutture possono essere pubbliche o private, come anche i loro membri. Le strutture possono contenere delle proprietà e metodi. Le strutture sono tipi di valore, mentre le classi sono tipi di riferimento. Una variabile di un tipo di struttura contiene i dati della struttura, anziché un riferimento ai dati come, invece, avviene per un tipo di classe. Una struttura non può essere vuota, mentre la classe può esserlo; la struttura non necessita di un costruttore mentre la classe si.
La struttura che si dichiara, per default, in Vb.Net è esclusivamente di tipo pubblica (public)mentre in C# è di tipo privata (private); quindi la visibilità è diversa, in quanto quella pubblica è visibile in tutto il programma, mentre quella privata solo nel contesto in cui è dichiarata.
Di seguito si riporta un esempio di una struttura e del suo utilizzo:
Vb.Net
'Dichiarazione di una struttura
Structure Persona
Dim Nome As String
Dim Cognome As String
'il metodo che visualizza un messaggio a video
Sub Messaggio()
MessageBox.Show(StrNome & " " & StrCognome)
End Sub
End Structure
C#
//Dichiarazione di una struttura
struct Persona
{
public string Nome;
public string Cognome;
//il metodo che visualizza un messaggio a video
public void Messaggio()
{
MessageBox.Show(Nome + " " + Cognome);
}
}
Mentre per il suo utilizzo basterà creare un’ istanza di tale oggetto.
Vb.Net
'richiamo la struttura
Dim StrucPersona As Persona
StrucPersona.Nome = "Emanuele"
StrucPersona.Cognome = "Mattei"
'Tramite il metodo visualizzo un mesaggio a video.
StrucPersona.Messaggio()
C#
//richiamo la struttura
Persona StrucPersona;
StrucPersona.Nome = "Emanuele";
StrucPersona.Cognome = "Mattei";
//Tramite il metodo visualizzo un mesaggio a video.
StrucPersona.Messaggio();
Le enumerazioni
Un altro tipo di dato sono le enumerazioni, le quali permettono di creare un numero limitato di variabili al loro interno; questo tipo di dato ha un set di valori fissi di tipo numerico; in questo modo, creando un’ enumerazione e nel richiamarne i vari membri, si migliora la leggibilità del codice. Di seguito si riporta un esempio:
Vb.Net
'creazione di un’ enumerazione che rappresenta i livelli
Enum livello As Integer
quadro = 0
primo = 1
secondo = 2
End Enum
'creo un oggetto di tipo livello (enumerazione)
Dim miosemaforo As livello
‘imposto un valore membro primo ha il valore 1
miosemaforo = livello.primo
'visualizzerà il valore 1
MsgBox(miosemaforo)
C#
//creazione dell'enumerazione
enum livello :int
{
quadro = 0,
primo = 1,
secondo = 2
}
//creo la mia variabile di tipo livello
livello miolivello;
//imposto il valore (membro primo ha il valore uno)
miolivello = livello.primo;
//visualizza il valore (1)
MessageBox.Show(Convert.ToString((int)miolivello));
Le condizioni logiche
Con le istruzioni di controllo si possono eseguire determinate parti di codice o eseguire solo alcune operazioni, se rispettano una condizione. Tramite le parole chiave if, else, possiamo far eseguire alcune istruzioni solo se tale condizione viene rispettata o meno. Inoltre esiste un'altra istruzione di controllo, select per VB.net o switch per C# .Di seguito si riportano alcuni esempi:
Gli operatori da utilizzare
Gli operatori riportati di seguito restituiscono true o false, in base al valore della condizione che si sta confrontando.
|
Tipo di confronto
|
Simbolo per Vb.Net
|
Simbolo per C#
|
|
Uguale
|
=
|
= =
|
|
Maggiore
|
>
|
>
|
|
Maggiore o uguale
|
>=
|
>=
|
|
Minore
|
<
|
<
|
|
Minore o uguale
|
<=
|
<=
|
|
Diverso
|
<>
|
!=
|
Gli operatori logici, riportati di seguito, restituiscono true se due o più condizioni sono vere; tramite questi operatori si possono confrontare più condizioni.
|
Tipo di operatore
|
Simbolo per Vb.Net
|
Simbolo per C#
|
|
And
|
and
|
&
|
|
or
|
or
|
||
|
|
not
|
isnot
|
!
|
|
And e se è true non verifica la seconda condizione
|
Andalso
|
&&
|
|
Orelse Se la prima condizione è true non verifica la seconda condizione
|
OrElse
|
!!
|
Vb.Net
La sintassi è la seguente:
if condizione = true then
codice
end if
Esempio:
'creo una variabile con il valore "A"
Dim StrTesto As String = "A"
'visualizzo un messaggio a video se tale variabile ha il valore "A"
If StrTesto = "A" Then
MsgBox("La variabile contiene il valore A")
End If
C#
La sintassi è la seguente:
If (condizione = true)
{
Codice
}
Esempio
//creo una variabile con il valore "A"
string sTesto = "A";
//visualizzo il messaggio a video se la condizione è vera
if (sTesto == "A")
{
MessageBox.Show("La variabile contiene il valore a");
}
Cambiando l’operatore logico di confronto possiamo porre altre condizione, per esempio verificare che il valore di una variabile sia maggiore del valore di un’altra variabile. Di seguito si riporta tale esempio: