Introduzione al linguaggio C# - Roberto Mana
←
→
Trascrizione del contenuto della pagina
Se il tuo browser non visualizza correttamente la pagina, ti preghiamo di leggere il contenuto della pagina quaggiù
Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Introduzione al linguaggio C#
Rev. Digitale 1.2 del 18/11/2017
Introduzione al Linguaggio C#
Il NET Framework ……………………..……………………………………………………….……… 3
Le variabili ……………………………………………………………………………………….…….. 4
Istruzioni Fondamentali ………………………………..…………………………………..…………… 5
Introduzione a vettori e matrici ………….……..…………………………………..…………………… 7
Le strutture ……………………………………..…………………………………..…………………… 7
Introduzione alla programmazione OOP ………..…….………………………………….……………. 8
Le classi base del NET Framework
System.Math ……………………………………………………………..…………………………… 11
Classi numeriche ………………………………..........................................………………………….. 11
System.Convert …………………………………...........................................……………………….. 11
System.Char ……………………………………...........................................………………………… 12
System.Random ……………………………………..............................................…………….……. 13
System.String …………………………………….............................................………………………. 13
Il cast dei puntatori …….…………………………………………………………………………..…... 15
Sintassi completa di MessageBox e InputBox ………………………………………………………... 16
Gestione delle Eccezioni Strutturate …………..…………….……………………………..…………. 17
Passaggio dei parametri per riferimento …………..…………….…………………………..…………. 19
Approfondimenti su Vettori e Matrici ………..……………….…………………..…………………. 19
Files e Directories ……………………………………………………………………..…..………….. 21
La classe Form
Proprietà di una Form …………………………………………………………………………………. 24
Richiamo di una API di Windows dall‟interno di una Form .………………………………..……….. 24
Ciclo di vita di una Form ………………………………………………………………………………. 25
I Controlli …………………………..…………………………………………………………..…….. 25
Principali Eventi Relativi alla Tastiera …………………………………………………………... 27
Principali Eventi Relativi al Mouse ……………………………………………………..………. 28
La Gestione del Fuoco ……………………………………………………………….………….. 29
Scansione di controlli simili ………………………………………………………………..………… 30
Creazione Dinamica dei Controlli ………………………………………………………..………….. 31
La classe system.windows.form ………………………………………………………………………. 33
Utilizzo degli oggetti Shapes …………………………………………………………………………. 34
I controlli Visuali
Text Box, Label …………………………………………………………………………………….…… 35
Command Button, Check Box, Option Button, Panel, GroupBox …....................................................... 36
List Box, Checked List Box, Combo Box ……………………..................................................………. 37
Timer ……………………………………………………………………………………….…………… 38
DataGridView ………………………………………….................................................……………… 39
Picture Box, Scroll Bar, Link Label …………………...............................................………………… 40
Menù ………………………………………………………………….………………….…………… 41
Dialog Box …………………………………………………………………………………..………… 42
La Stampa ………………………………………………………………………………………………. 44
Status Bar e Tool Bar …………………………………...…............................................…………….. 46
ImageList …………………………………………………..............................................……….…… 47
Rich Text Box ………………………………………………..............................................………….. 47
I Controlli Provider: ToolTip, ErrorProvider, HelpProvider …...............................................……….. 48
Altri Controlli ……………………………………………….…………………………………………. 50
pag 1Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Gli oggetti non visuali
L‟oggetto Application …………………………………………………………………………………. 52
L‟oggetto Font …………………………………………………………………………………..…….. 52
L‟oggetto Color …………………………………………………………………………..……..……. 53
Richiamo di Applicatvi Esterni …………………………………………………………………..……. 53
L‟oggetto.Date ………….……………….…………………………………………………….……… 54
L‟oggetto Clipboard ………………………………………………………………………..…………. 56
L‟oggetto Cursor ………….………………………………………………………………..…………. 56
L’oggetto Enum ………….……………………………………………………………………………. 57
L‟oggetto Array ……………………………………………………………………………..…………. 58
Gòi oggetti Collections: List, Stack, Queue, Hashtable ………..……………………………………… 60
Trascinamento con il mouse …………………………………………………………………………… 63
pag 2Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Il NET Framework
Compilazione delle applicazioni tradizionali
Terminato lo sviluppo dell‟applicazione, questa deve essere compilata per creare un file binario detto eseguibile.
Tutte le librerie utilizzate dalla‟applicazione vengono linkate staticamente all‟applicazione al momento della
creazione. Pertanto l‟eseguibile contiene al suo interno tutte le librerie necessarie alla sua esecuzione e qpuò
essere eseguito su qualunque macchina senza ulteriori installazioni.
Concetto di DLL (Dynamic Link Library)
Col passare degli anni le funzioni utilizzate da un programma aumentano sempre di più e diventa impossibile
contenerle tutte all‟interno di un unico eseguibile. Nasce il concetto di DLL. Molto funzionalità di base (ad
esempio le funzioni di input / output, le funzioni di gestione delle finestre grafiche, le funzioni di accesso ai file)
vengono memorizzate all‟interno di DLL esterne che devono essere distribuite insieme all‟applicazione.
Una DLL può essere vista come una classe compilata. Se invece di compilare un „intero progetto dotato di main si
compila una singola classe sprovvista del main, invece di un file eseguibile viene creata una libreria (detta DLL)
simile all‟eseguibile ma che non può essere eseguito autonomamente.
La DLL sono pertanto librerie binarie che verranno collegate dinamicamente all‟eseguibile soltanto in fase di
RUN TIME. Quando si crea un progetto che intende utilizzare una DLL, è sufficiente indicare nel progetto il path
del file contenente la DLL. Al momento dell‟esecuzione, quando l‟eseguibile avrà necessità di accedere ad una
funzione contenuta all‟interno della DLL, provvederà autonomamente a caricare in memoria la DLL, linkarla
dinamicamente al progetto ed eseguire la specifica funzione richiesta. Una stessa DLL può essere
contemporaneamente utilizzata da più processi.
Molte DLL utilizzate in un certo ambiente di sviluppo vengono installate sulla macchina al momento
dell‟installazione dell‟ambiente di sviluppo. Quando poi l‟utente sposta l‟eseguibile su un‟altra macchina
l‟eseguibile non funziona perché manca qualche DLL. Non sempre è facile recuperare le DLL mancanti, e
nemmeno di può pensare di reinstallare sulla macchina del cliente finale l‟intero ambiente di sviluppo.
Il NET Framework [300 MB]
Tre grandi innovazioni:
1) Tutte le DLL necessarie all’esecuzione Run Time sono raccolte all’interno del NET Framework, in modo
che, quando si distribuisce una applicazione, non ci sia più la necessità di portarsi dietro tutte le DLL ma, sul
nuovo PC, sarà sufficiente installare il NET Framework, scaricabile gratuitamente dal sito Microsoft.
Siccome esistono versioni differenti di Visual Studio che utilizzano NET Framework differenti, occorre fare
attenzione ad installare sul PC del cliente finale la stessa versione di NET Framework utilizzato per lo sviluppo:
Visual Studio 2002 -> Framework 1.0
Visual Studio 2003 -> Framework 1.1
Visual Studio 2005 -> Framework 2.0
Visual Studio 2008 -> Framework 3.0 (ad oggi Gennaio 2010 siamo alla release 3.5 di Visual Studio 2008)
2) L‟applicazione finale non comunica direttamente con il SO, ma comunica solo con il NET Framework, per cui
diventa portabile su qualunque SO per i quali è disponibile la versione adeguata del NET Framework.
3) Il compilatore, a differenza dei tradizionali linguaggi di prg, non genera codice nativo binario (eseguibile
direttamente dalla CPU), ma genera il cosiddetto MsIL (Miscosoft Intermediate Language). A differenza di java
che è interpretato, in NET quando una applicazione viene lanciata, essa richiama direttamente una DLL (MsCorEE)
(run time manager di NET) che contiene un compilatore Just in Time (compilatore JIT) il quale provvede a
compilare il codice intermedio in codice nativo eseguito sulla CPU. Ogni procedura viene compilata soltanto quando
viene richiamata per la prima volta, senza appesantire il tempo di lancio. Inoltre la compilazione Just in Time può
ottimizzare il codice sulla base del SO su cui viene eseguita.
pag 3Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Le Variabili
I tipi che iniziano con la lettere Maiuscola rappresentano le classi native del NET Framework.
I tipi che iniziano con lettera minuscola rappresentano le varabili scalari boxate per C#
Classe scalare VB scalare C#
Byte Byte byte 1 byte Numerico 0 - 255
Char Char char 2 byte chr UNICODE. No valore numerico
Int16 Short short 2 byte ± 32000
Int32 Integer int 4 byte ± 2 Mld
Int64 Long long 8 byte ± 9 Mld di Mld
Single Single float 4 byte
Double Double double 8 byte
Boolean Boolean bool 2 byte True = -1, False = 0
String String string 10 byte + 2 * char (1 Mld Char)
Date Date date 8 byte Dal 1 1 0001 al 31 12 9999
Object Object 4 byte Riferimento a oggetto (void *)
String e Date sono degli Oggetti che, per comodità, sono istanziabili anche senza il new.
Le variabili string non sono accessibili in scrittura diretta ma solo in concatenamento.
Tutti i metodi che modificano la stringa in realtà istanziano e restituiscono una nuova stringa
Il vecchio standard ANSI ad un byte per carattere è sostituito dallo standard UNICODE. Lo standard ANSI ad un
byte prevedeva 256 simboli, di cui i primi 128 erano fissi (codici ASCII) mentre i 128 successivi dipendevano
dall‟applicazione (e dalla lingua). Lo standard UNICODE prevede invece 65536 caratteri fissi, contemplando
tutti i possibili caratteri (ad esempio il codice 12398 rappresenta il carattere N in giapponese). Nei 10 caratteri di
intestazione viene memorizzata la lunghezza della stringa. Non sono supportate le stringhe a lunghezza fissa.
Dichiarazione delle variabili
Stessa sintassi dell‟ANSI C.
Per i nomi delle variabili si consiglia la notazione camel Casing del tipo nomeCognomeIndirizzo,
con la 1° lettera minuscola e le iniziali delle parole successive Maiuscole.
Sono consentite Dichiarazioni multiple su una stessa riga: int a, b, c
Variabili di blocco
E‟ consentita la dichiarazione di variabili direttamente all‟interno di un blocco di istruzioni (Variabili di blocco).
Se però la variabile viene inizializzata e la dichiarazione si trova all‟interno di un ciclo, allora l‟inizializzazione
viene ripetuta tutti i giri.
for (int i = 0; i < 100; i++) {
int a=0;
a = a+i;
} // a = 99
Per evitare questo problema l‟inizializzazione può essere eseguita all‟interno del ciclo for:
for (int a =0, i = 0; i < 100; i++) {
Attenzione che non è possibile riutilizzare il nome di una variabile già esistente all‟interno della procedura (errore
di compilazione). E‟ invece consentito avere una variabile di blocco con lo stesso nome di una variabile globale.
Attenzione anche al fatto che il tempo di vita della variabile di blocco coincide con quello dell‟intera procedura.
Se si ripassa una seconda volta nel blocco, la variabile viene reinizializzata al valore di inizializzazione ma,
in assenza di inzializzazione esplicita, la variabile mantiene il valore che aveva in uscita dal blocco.
pag 4Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Le costanti
Non sono supportate le define, ma la costante viene dichiarata come se fosse una variabile semplicemente
anteponendo la parola chiave const davanti. Anche le constanti vengono allocate in memoria.
const int n = 3;
const string s = "Salve mondo";
Lettura e Scrittura su Console
String s;
s = Console.readLine(); // legge una stringa da tastiera
Console.write(s); // scrive la stringa s senza andare a capo
Console.writeLine(s); // scrive la stringa s e va a capo
Parametri opzionali in una funzione
Per rendere opzionale un parametro all‟interno di una funzione è sufficiente specificare un valore di default
int modifica (int paramObbligatorio , int paramOpzionale = 0)
Variabili static
In C# non sono supportate le variabili statiche all‟interno di un metodo. Al loro posto si usano i metodi statici.
Istruzioni Fondamentali
Operatori
Aritmetici
+ * - / La divisione fra interi tronca all‟intero più basso
% Resto della divisione fra interi
Logici
&& || !
Nel caso della And, se il primo test fallisce, i test successivi non vengono eseguiti.
Nel caso della ||, se il primo test è vero, i test successivi non vengono eseguiti.
Confronto
== != > >= <Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
L’istruzione switch
int n = 2; string s = "aa";
switch (n) {
case 1:
case 2:
MessageBox.Show("uno or due");
break;
default:
MessageBox.Show("other");
break;
}
switch (s) {
case "aa":
MessageBox.Show("aaa");
break;
case "bb":
MessageBox.Show("bbb");
break;
default :
MessageBox.Show("other");
break;
}
A differenza di ANSI C la variabile da confrontare può essere di qualunque tipo, compreso STRING.
(in ANSI C erano ammessi solo int e char)
A differenze di ANSI C ogni blocco case contenente delle istruzioni deve essere chiuso mediante un
break, altrimenti si verifica un errore in compilazione. Anche il default deve essere chiuso da un break.
Purtroppo a differenze di VB dopo ogni singolo case può essere specificato sempre solo un UNICO
valore. Non è possibile fare delle OR o delle AND o impostare degli intervalli.
I Cicli
for (i=1; iInformatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Introduzione ai Vettori
Sono a base 0, cioè partono da 0 e vanno fino a N -1.
Devono essere trattati come oggetti, per cui non è ammessa la tipica dichiarazione
int vect[10]; „Errore di sintassi
Occorre invece utilizzare la seguente sintassi :
int [] vect1; // equivale all‟ANSI C int * vect1
vect1 = new int[10];
int [] vect1 = new int[10];
for (int i = 0; i < 10; i++) vect1[i] = i;
In caso di inizializzazione diretta occorre omettere la dimensione
int [] vect2 = new int [] { 0, 1, 2, 3, 5, 8, 13 };
In questo caso anche il new può essere omesso:
int [] vect2 = { 0, 1, 2, 3, 5, 8, 13 };
E‟ ammesso l‟utilizzo di una variabile per definire la dimensione:
int n = 10; int[] vect3 = new int[n];
Le Matrici
int[,] mat = new int[2,3];
// Matrice di 2 righe x 3 colonne, entrambe a base 0.
// Anche la matrice può essere inizializzata in fase di dichiarazione:
int[,] mat = {{11, 12, 13}, {21, 22, 23}};
.Length Proprietà ReadOnly = Restituisce il numero complessivo di elementi contenuti nella matrice,
conteggiando però l‟intero rettangolo
.GetLength(0) Proprietà ReadOnly = Restituisce il numero di righe
.GetLength(1) Proprietà ReadOnly = Restituisce il numero di colonne (2° dimensione)
for (int i = 0; i < mat.GetLength(0); i++)
for (int j = 0; j < mat.GetLength(1); j++)
MessageBox.Show(mat[i, j].ToString());
Le Strutture
Come in ANSI C, in C#, le strutture, a differenza delle classi,
sono considerate variabili di tipo scalare quindi non serve il new
non sono ereditabili.
All‟interno di una struttura è possibile definire Variabili ma anche funzioni.
I membri di una struttura possono essere Private (default) oppure Public.
struct s_Libri {
public int codice; // non sono consentite le inizializzazioni
public string autore;
public string titolo;
public string visualizza() {
string s = codice.ToString() + " " + autore + " " + titolo;
Console.Write(s); return s;
}
};
pag 7Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Dichiarazione di un record e inserimento dei dati
s_Libri libro; // struct DEVE essere omesso
libro.codice = 3;
libro.autore = "Pirandello";
libro.titolo = "Uno nessuno centomila";
libro.visualizza();
Operazioni sui record
Come in ANSI C non è consentito il confronto fra record, che devono essere confrontati sui singoli campi.
Essendo variabili scalari, i record possono essere copiati con la semplice assegnazione: libro2 = libro1;
Notare che così facendo ogni campo di libro1 viene duplicato all‟interno di libro2, comprese le stringhe, per le
quali, come detto è stato ridefinito l‟operatore di assegnazione (il setter) che ogni volta istanzia una nuova stringa.
Introduzione alla Programmazione Object Oriented
Paradigma = Modello utilizzato per affrontare / risolvere un problema
Paradigma Imperativo: Esprime la strategia risolutiva di un problema attraverso una successione sequenziale di
comandi ed un controllo di stati (es. Continua a ciclare fino a quando non arriva un numero negativo).
Paradigma della programmazione ad oggetti Nuova modalità di progettazione delle applicazioni. Non si pensa
più a quale sequenza di operazioni è necessaria, ma a quali oggetti sono necessari. Risoluzione dei problemi
mediante la costruzione di oggetti dedicati. OOP esprime la strategia risolutiva di un problema attraverso una
generalizzazione della progettazione di oggetti riutilizzabili: Essa parte dalla costruzione di oggetti elementari per
costruire via via oggetti sempre più complessi (estensibilità del codice).
Introduzione agli oggetti
Un oggetto può essere inizialmente visto come un contenitore che comunica con l‟esterno mediante un insieme di
proprietà, metodi ed eventi. Il main (programma principale) rappresenta l’utilizzatore dell’oggetto.
Proprietà
Eventi
Metodi
Le Proprietà sono “variabili” definite all'interno dell'oggetto.
I Metodi sono “funzioni / procedure” definite all'interno dell'oggetto che operano sulle Proprietà
Gli Eventi rappresentano una nuova caratteristica della programmazione ad oggetti. Sono procedure richiamate
automaticamente quando si verifica una particolare situazione dovuta ad una causa interna (ad esempio allo
scadere di un certo timeout) oppure in conseguenza di eventi esterni come ad esempio il click del mouse.
Per accedere da codice ai membri di un oggetto di usa l‟operatore . (puntino ), esattamente come per i record
Es: myLibro.titolo = “I Promesi Sposi”;
Definizione di CLASSE
Le classi costituiscono la base della programmazione ad oggetti. Si supponga di dover rappresentare e gestire una
certa realtà (ad es la biblioteca di una scuola). Una classe è una porzione di codice (contenuta normalmente in un
apposito file .cls) contenente un insieme di dati (cioè le PROPRIETA’: Titolo del libro, Autore, Casa Editrice)
più il codice di elaborazione dei dati stessi (cioè i METODI che agiscono sui dati. Ad esempio un Motodo per
l‟aggiunta di un nuovo libro oppure per la gestione di un prestito). Una Classe definisce le caratteristiche (cioè
Proprietà, Metodi ed Eventi) dell'oggetto, esattamente come la struttura definisce le caratteristiche dei record. Es:
pag 8Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
class Libro { // Le classi si scrivono con la prima lettera Maiuscola
public int codice;
public string Titolo;
public void salvaSuFile() {
// Codice per salvare su file il libro corrente (codice e titolo)
}
}
Gli EVENTI sono particolari metodi (metodi di evento) che non devono essere richiamati dall‟utente della classe
(main) ma che vengono eseguiti automaticamente in corrispondenza di situazioni interne al programma o esterne.
Definizione di OGGETTO
Un oggetto rappresenta una istanza della classe, cioè la sua allocazione in memoria.. Nel caso delle classi non
si parla più di allocazione ma di ISTANZA. In genere si parla più frequentemente di oggetto che non di classe.
La classe può essere vista semplicemente come codice di definizione dell‟oggetto.
Per poter utilizzare la classe Libri, l'applicazione dovrà prima creare una istanza mediante l‟operatore new:
Libro mioLibro;
mioLibro = new Libro(); // sempre con le parentesi
La prima riga crea un riferimento (puntatore) ad un oggetto di tipo Libro non ancora esistente in memoria.
Questo riferimento contiene pertanto il valore null (che in C# significa puntatore non inizializzato).
La seconda riga, mediante l‟operatore new, crea una nuova istanza della classe Libro e restituisce il puntatore
all‟oggetto che viene copiato all‟interno della variabile mioLibro.
Esattamente come in C i Riferimenti (cioè i Puntatori), pur essendo sempre indirizzi, sono TIPIZZATI.
Cioè un puntatore può essere dichiarato come Puntatore generico oppure come Puntatore ad uno specifica classe:
ANSI C C#
Generico void * pt; Object pt;
Tipizzato Libro * mioLibro; Libro mioLibro;
E‟ anche possibile Dichiarare un Riferimento e Istanziare l‟Oggetto all'interno della stessa riga:
Libro mioLibro = new Libro(); // sempre con le parentesi
Per accedere da codice ai membri di una classe si usa il nome del puntatore seguito dall‟operatore puntino
mioLibro.codice = 65
mioLibro.salvaSuFile()
Riassumendo :
Classe = Codice Descrittivo di un oggetto (template)
Oggetto =Istanza in memoria della Classe.
Visibilità
I membri di una classe (Proprietà, Metodi ed Eventi) possono essere definiti come Private (default), cioè visibili
solo all‟interno di una classe, oppure Public, cioè visibili anche all‟esterno della classe.
Le TRE caratteristiche di una classe
Incapsulamento : Una classe è l‟unica proprietaria dei suoi dati. I Dati sono memorizzati in un‟area di memoria
non direttamente accessibile alle altre porzioni di programma. La classe può controllare il valore assegnato alle
variabili interne prima che i valori stessi vengano memorizzati, con la possibilità di rifiutare valori non validi.
L‟incapsulamento consente di modificare il funzionamento della classe senza interagire con l‟applicazione esterna
Ereditarietà : Da una classe già esistente è possibile derivare una nuova classe (classe derivata) che erediti
proprietà e metodi della classe base con possibilità di aggiungere nuove funzionalità. Riutilizzo del software.
Polimorfismo : Più classi completamente diverse possono mostrare all‟esterno interfacce simili cioè proprietà e
metodi con lo stesso nome e la stessa firma. Facilità di utilizzo e possibilità di gestire gruppi di controlli con una
unica variabile ad esempio di tipo Control.
pag 9Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Esempio di progetto OOP
Realizzare un programma per il calcolo degli interessi che si avranno al termine di un investimento pluriennale.
Utilizzando OOP cambia completamente la strategia risolutiva. I problemi si risolvono non più attraverso una
analisi sequenziale, ma attraverso l’individuazione e la realizzazione di appositi oggetti.
Non si pensa più a quale sequenza di operazioni è necessaria, ma a quali oggetti sono necessari
a) Approccio sequenziale ::
1. Leggere il capitale iniziale
2. Leggere il tasso di interesso annuo
3. Leggere la durata dell‟investimento espresso in anni
4. Fare un ciclo per il calcolo degli interessi annuali
5. Visualizzare il risultato
b) Approccio OOP ::
1. Creare una classe Investimenti
2. Impostare le Proprietà capitaleIniziale, interesseAnnuo, durata
3. Richiamare l‟apposito metodo eseguiCalcolo( )
4. Leggere e Visualizzare il risultato
Nella OOP il passo iniziale è individuare e costruire gli oggetti necessari alla soluzione del problema e quindi
spostare tutta la logica all‟interno della classe. Nel caso precedente si avrà il seguente codice:
class Investimenti {
public int capitaleIniziale;
public int interesseAnnuo;
public int durata;
private double risultato;
public double eseguiCalcolo( ) {
risultato = capitaleIniziale;
for (int i = 0; i < durata; i++)
risultato += risultato * interesseAnnuo / 100;
return risultato;
}
int Main( ) {
Investimenti investimento = new Investimenti();
investimento.capitaleIniziale = Convert.ToInt32(InputBox("Inserire capitale Iniziale"));
investimento.interesseAnnuo = Convert.ToInt32(InputBox("Inserire Interesse Annuo"));
investimento.durata = Convert.ToInt32(InputBox("Inserire Durata"));
double ris = investimento.eseguiCalcolo( );
MessageBox.Show (ris.ToString());
}
L‟approccio OOP è sicuramente più oneroso nel caso di piccole applicazioni, ma è sicuramente vantaggioso nel
caso di applicazioni di dimensioni notevoli, in cui, una volta stabilite le specifiche della classe, gruppi di lavoro
differenti possono contemporaneamente dedicarsi allo sviluppo di oggetti differenti ed eventualmente riutilizzabili
Membri di Istanza e Membri Statici di una classe
Una classe può avere :
proprietà e metodi di istanza, cioè legati alle istanze della classe, e richiamati tramite il nome dell‟istanza
ES: mioLibro.metodoDiIstanza( ); oppure mioLibro.salvaSuFile();
proprietà e metodi statici (o di classe), cioè che non dipendono dalla singole istanze, ma dalla classe vera e
propria, e vengono richiamati non tramite il nome dell‟istanza ma direttamente tramite il nome della classe
ES: Libro.MetodoStatico( ); oppure int nLibri = Libro.count;
In corrispondenza del primo accesso ad un membro statico, la classe viene caricata in memoria e da quel momento
tutti i suoi membri statici diventano accessibili (come le funzioni di libreria della programmazione sequenziale).
pag 10Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Classi Statiche [Per definire una classe statica è sufficiente definire il costruttore come privato]
a) contengono soltanto membri statici (libreria di funzioni)
b) non possono essere istanziate esplicitamente.
In DOT NET ogni cosa è un oggetto. Esempi :
Classi statiche: Math, ControlChars. Sono le più semplici perchè possono essere utilizzate senza essere istanziate
User Class Classi definite dall'utente all'interno dell'Applicazione. (es ClsLibri)
Form Class. Oggetto che sta alla base della programmazione visuale .
I controlli sono particolari Classi che possono essere istanziate soltanto all'interno di una Form .
Le classi base del NET Framework
La classe Statica System.Math
Sqrt (Num) As Double Restituisce la radice quadrata di un numero. In caso di numero negativo, anziché
sollevare una eccezione, restituisce il valore speciale NaN. Esempio:
double ris = Math.Sqrt(a);
if (double.IsNaN(ris) == true)
MessageBox.Show("Not a Number");
else
MessageBox.Show("OK");
Abs (Num) As Double Restituisce il valore assoluto di un numero
Sign (Num) As Integer Restituisce il segno di un numero (+1 per numeri positivi, -1 per i negativi)
Max(Num1, Num2) Restituisce il massimo fra due valori
Min(Num1, Num2) Restituisce il minmo fra due valori
Pow(Base, Esp) Elevamento a potenza : BaseEsp
Round (Num, N) As Double Arrotonda il numero Num con N cifre dopo la virgola. Attenzione che, anche
impostando N = 2, il numero 3,00 viene comunque restituito come 3
Ceiling(Num) Arrotondamento all‟intero superiore
Floor(Num) Troncamento all‟intero inferiore
Sin (Angolo) As Double Cos (Angolo) As Double Restituisce seno / coseno di un angolo espresso in radianti
Exp (Num) As Double Restituisce l‟esponenziale naturale di un numero ex
Log (Num) As Double Restituisce il logaritmo naturale di un numero
Log10 (Num) As Double Restituisce il logaritmo in base 10 di un numero
Math.PI 3,1415 Math.E 2,7182
Le classi numeriche (Integer, Short, Long, Single, Double)
Proprietà / Metodi di Istanza
.ToString( ) Converte in stringa. Come primo parametro è possibile passare a ToString una stringhe di
formattazione. Come eventuale 2° argomento un oggetto NumberFormatInfo contenente le
impostazioni da utilizzare per Separatore Decimale, Separatore Migliaia, etc.
.CompareTo(N1 As Num) Analogo al CompareTo delle Stringhe. Restituisce –1 0 +1 a seconda che il numero
corrente sia min, eq o magg di N1. N1 deve essere dello stesso tipo del N corrente.
Proprietà / Metodi Statici
.MaxValue Max numero memorizzabile [32.767 su Short] x = Short.MaxValue
.MinValue Min numero negativo memorizzabile [-32.768 su Short] x = Double.MinValue
pag 11Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Per quanto concerne le sole classi Single e Double:
.IsNaN(x) Restituisce True se la variabile x contiene il valore NaN
.NaN Può essere usato in assegnazione: x = Double.NaN
.Epsilon Più piccolo numero positivo memorizzabile (risoluzione) Single.Epsilon = 1,4E-45
.tryParse(var, out dest) Se riesce a convertire var in int lo salva nella variabile int dest, altrimenti nulla.
La classe Statica System.Convert
Il cast inline (o direct cast) dell‟ANSI C può essere eseguito soltanto sui tipi base scalari e non sulle stringhe.
La classe Convert, viene utilizzata per convertire un qualsiasi numero in stringa oppure una stringa nella
corrispondente variabile scalare. Può anche essere utilizzata per conversioni scalare scalare, (ad es da int a char),
per le quali però è molto più comodo il cast inline.
Di seguito sono riportate i principali metodi di conversione contenti nella classe Convert.
string s;
Convert.ToInt32 (s) // arrotondano tutte all‟intero più vicino
Convert.ToInt16 (s)
Convert.ToInt64 (s)
Convert.ToSingle(s)
Convert.ToDouble (s)
Convert.ToBoolean (s) // 0 -> False, altrimenti True
Convert.ToChar (s) // var deve essere lunga 1 solo carattere
Convert.ToByte (s)
Convert.ToDateTime (s) // string s = "30/8/2011";
Convert.ToString (var)
Tutti questi metodi accettano come 2° parametro un oggetto NumberFormatInfo per l‟impostazione del formato.
Funzionano solo i con i valueType (lettera iniziale minuscola) e non con le classi (lettera iniziale Maiuscola)
La classe System.Char
Il tipo char è analogo a quello dell’ANSI C.
L‟unica differenza è che non si può assegnare un valore numerico ma solo il carattere ASCII: char c = „a‟;
La classe Char dispone inoltre dei seguenti metodi statici:che possono tutti ricevere come parametro
o un carattere char oppure un singolo carattere all‟interno di una stringa.
.IsDigit(char c) Restituisce True se il carattere è un carattere numerico.
.IsDigit(string s, int pos) Restituisce True se il carattere alla posizione pos è numerico
.IsNumber (char c) Uguale a IsDigit
.IsLetter (char c) Restituisce True se il carattere è una lettera
.IsLetterOrDigit (char c) Restituisce True se il carattere è una lettera o un numero
.IsUpper (char c) Restituisce True se il carattere è una lettera maiuscola
.IsLower (char c) Restituisce True se il carattere è una lettera minuscola
.IsWhiteSpace (char c) Restituisce True se il carattere è uno spazio
.IsPunctuation (char c) Restituisce True se il carattere è una punteggiatura
.IsSymbol (char c) Restituisce True se il carattere è un simbolo stampabile
.IsControl (char c) Restituisce True se il carattere è un carattere di controllo (Ascii < 32)
Tutti questi metodi presentano una seconda firma metodo(s, i) in cui il primo parametro è una stringa, mentre
il secondo parametro consente di eseguire il controllo sul carattere i-esimo della stringa s.
.ToUpper (char c) Restituisce il carattere c convertito in maiuscolo
.ToLower (char c) Restituisce il carattere c convertito in minuscolo
pag 12Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
La classe System.Random
.Next(A, B) Restituisce un numero intero compreso tra A (compreso) e B (escluso)
.NextDouble( ) Restituisce un numero double compreso tra 0 (compreso) e 1 (escluso)
.NextBytes (vectBytes) Riempie il vettore (indipendentemente dalla sua lunghezza) con numeri tra 0 e 255
Random rnd = new Random( );
int n;
n = rnd.Next(A, B+1);
Se al costruttore non viene passato nessun parametro, la sequenza risulta perfettamente casuale (legata a
data e ora attuali).
Se invece al costruttore si passa un numero Int16, verrà generata una ben precisa sequenza ripetuta ad
ogni lancio del programma (sequenza che dipende dal numero impostato).
Se A == 0 può anche essere omesso.
La classe System.String
In C#, come in VB, la Stringa è un Oggetto per il quale è stato ridefinito l‟operatore di assegnazione.
Cioè l‟assegnazione s2 = s1 non copia il puntatore s1 dentro s2, ma istanzia un nuovo oggetto all‟interno del quale
viene copiato il contenuto di s1 e poi si assegna a s2 l‟indirizzo di questo oggetto.
Per istanziare una stringa si possono utilizzare indifferentemente le seguenti sintassi
string s;
string s = new string(“salve mondo”);
La prima sintassi richiama implicitamente un costruttore privo di parametri.
La seconda sintassi, per non creare confusione, è utilizzabile soltanto con costruttori dotati di parametri.
In C# come in Java l’oggetto string è un oggetto invariante (immutable cioè non modificabile).
I vari metodi di elaborazione delle stringhe (ad esempio il metodo replace) restituiscono in realtà un puntatore ad
una nuova stringa.
Per modificare una stringa si possono adottare diverse „strategie‟. Le migliori sono le prime 2:
riassegnare il vecchio puntatore alla nuova stringa:
s = s.Replace('v', 'x');
costruire una nuova stringa con concatenamenti successivi
s = s + “*”;
convertirla in un vettore di caratteri
Le stringhe possono essere convertite nel vecchio vettore di caratteri dell'ANSI C e viceversa.
Il vettore di caratteri presenta però l‟inconveniente che non esistono funzioni per la sua visualizzazione e
deve essere pertanto sempre riconvertito in stringa. Scomodo.
string s = "salve mondo";
char [] v;
v=s.ToCharArray();
s = new String(v);
utilizzare l’oggetto string builder
StringBuilder sb = new StringBuilder(s);
sb[3] = 'x';
s = sb.ToString();
Sono tutte tecniche valide però bisogna ricordare che una stringa è pur sempre un oggetto . Ad esempio:
pag 13Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
int main(){
string s = "salve mondo";
modifica (s);
MessageBox.Show(s);
}
void modifica (string s){ // Viene passato il puntatore !
s = s.Replace('v', 'x');
}
Dopo il replace il puntatore s punta ad nuova stringa istanziata da replace, ma si tratta del puntatore locale !
Il problema può essere risolto passando la stringa per riferimento (indirizzo del puntatore) modifica(ref s)
Proprietà e Metodi di Istanza
[i] Accede in lettura all‟i-esimo carattere della stringa che viene restituito come Char.
.Length Proprietà contenente il numero di caratteri della stringa.
.Substring(start As Integer, [len As Integer]) Estrae una sottostringa dalla stringa corrente, partendo dalla
poszione start con lunghezza len. Se len non è specificato estrae fino a fine stringa
.IndexOf(s1 As String [start As Integer], [end As Integer]) Ricerca la sottostringa s1 all‟interno della stringa
corrente. Restituisce l‟indice della prima corrispondenza. La ricerca può essere compresa tra un indice
iniziale ed un indice finale. Restituisce –1 se fallisce.
.LastIndexOf(s1 As String [start As Integer], [end As Integer]) Come la precedente, ma restituisce l‟indice
dell‟ultima occorrenza. Comincia a cercare partendo da start e andando all'indietro. Se start è omesso
parte dalla fine della stringa. Ad esempio LastIndexOf(“ax” 3) ricerca la sottostringa “ax” partire dalla
posizione 3 andando a ritroso fino all‟inizio della stringa. Cioè confronta i caratteri 3 e 4 con “ax”. Se
non fanno match decrementa la posizione e confronta i caratteri 2 e 3 con “ax” e così via.
.IndexOfAny(chr As Char( ), [start As Integer], [end As Integer]) Ricerca uno qualsiasi dei caratteri contenuti nel
vettore e e restituisce l‟indice della prima ricorrenza oppure –1 se fallisce.
.LastIndexOfAny(chr As Char( ), [start As Integer], [end As Integer]) restituisce l‟indice dell‟ultima occorrenza.
.ToUpper( ) Restituisce la stringa convertita in maiuscolo
.ToLower( ) Restituisce la stringa convertita in minuscolo
.Replace(search As String, replace As String) Sostituisce tutte le ricorrenze della prima sottostringa con la
seconda. Restituisce l‟intera stringa convertita che deve eventualmente essere rassegnata alla variabile.
.Insert(pos As Integer, s1 As String) Aggiunge la sottostringa s1 davanti al carattere pos della stringa corrente,
spostando automaticamente verso destra gli altri caratteri
.Remove(start As Integer, len As Integer) Elimina il numero di caratteri specificato partendo dalla posiz indicata.
.Split(vectChr As Char( )) Esegue lo split della stringa in un vettore, secondo uno qualunque dei qualificatori.
.EndsWith(string substr ) if(s.EndsWith(“.txt”)) valido = true;
.StartsWith(s1 As String) As Boolean. Restituisce True se la stringa corrente inizia con la sottostringa indicata in s1
.Trim([vectChar As Char( )]) Se non si specifica nessun parametro, elimina gli spazi iniziali e finali dalla stringa
corrente. In alternativa è possibile specificare un vettore di caratteri. Trim eliminerà tutti i caratteri iniziali
e finali contenuti nel vettore. Es Dim cArr( ) As Char = {Cchar(“ “), ControlChars.Tab} s = s.Trim(cArr)
.TrimStart e .TrimEnd analoghi a .Trim ma agiscono solo sui caratteri iniziali / finali.
.PadRight(len As Integer, [chr As Char]) Aggiunge tanti spazi a destra fino ad un numero complessivo di len
caratteri. E‟ possibile specificare come secondo parametro un carattere diverso dallo spazio.
Es s = s.PadRight(16, CChar(“0”) Aggiunge tanti zeri fino ad una lunghezza complessiva di 16
.PadLeft(len As Integer, [chr As Char]) Simile alla precedente ma aggiunge a sinistra. La str viene re istanziata.
.Equals(string s2) Restituisce true se la stringa corrente è uguale a s2. Produce lo stesso effetto di ==.
.CompareTo(s2 As String) In C# non è possibile confrontare due stringhe in modo diretto con gli operatori <
e > ma occorre utilizzare questo metodo oppure, meglio ancora, il metodo statico .Compare( )
.CompareTo( ) Confronta la stringa corrente con s2. Restituisce –1 0 +1 a seconda che la stringa corrente sia
minore, =, maggiore di s2. Solo Case Sensitive.
.Clone( ) Restituisce una copia della stringa corrente. Prodceuce lo stesso effetto dell'operatore di assegnazione.
pag 14Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Il metodo di istanza .ToString(“N4”) disponibile per qualsiasi tipo di oggetto, converte l‟oggetto in questione in
stringa applicando la formattazione indicata dal parametro. I caratteri di formattazione riconosciuti sono:
N (Number), D(Intero), C(Currency), E(Scientifico), F(Floating Point), P(Percent), X(Esadecimale)
Dopo N è possibile aggiungere un numero intero che indica il numero di cifre da utilizzare dopo la virgola
Dopo D è possibile aggiungere un intero che indica il numero di cifre complessive di visualizzazione. Se il
numero risulta minore di questa lunghezza, viene completato con un certo numero di zeri all‟inizio della stringa
Dopo F è possibile aggiungere un numero intero che indica il numero di cifre da utilizzare dopo la virgola
Il formato E mostra il numero come nnnnEeee. Dopo E è possibile specificare il numero di cifre della mantissa.
Il formato P converte un numero tra 0 e 1 in una percentuale con 2 cifre fisse dopo la virgola
Il formato X converte un numero intero in stringhe esadecimale. Specificando una lunghezza es :X8 verranno
eventualmente inseriti degli zeri in testa. Sono inoltre consentite maschere personalizzate.
Se la variabile è di tipo data / ora, viene riconosciuta una lunga lista di indicatori riportata nella tabella allegata.
Scansione di un vettore con il ciclo foreach
foreach (char c in s) MessageBox.Show(c.ToString());
Metodi Statici
.Intern (s As String) consente di memorizzare la stringa s all‟interno di una cache che ne velocizza l‟accesso. Es
s1 = String.Intern(s1)
.IsInterned (s As String) Verifica se la stringa s si trova nella cache (nel qual caso restituisce il puntatore alla
stringa stessa), oppure no (nel qual caso restituisce Nothing)
.Concat (s1, s2, ….) concatena un numero arbitrario di argomenti String (o Object convertibili in String).
.Compare (s1, s2, [Mode]) Confronta s1 con s2 e restituisce 0 se sono uguali, 1 se s1 > s2, -1 se s1 < s2.
Mode è un boolean dove False (default) indica case sensitive, True indica invece case unsensitive
.Compare (s1, pos1, s2, pos2, Qta, [Mode]) Versione Overload della precedente. Confronta Qta caratteri di s1, a
partire dalla posizione pos1, con Qta caratteri di s2, a partire da pos2. Mode è lo stesso di prima.
I metodi Compare utilizzano le impostazioni della lingua locale, che ne rallenta l‟esecuzione
.CompareOrdinal (s1, s2, [Mode]) Identico a Compare senza però considerare la lingua locale. Più veloce.
.Format Formattazione di una stringa includendo una o più variabili.
msg = String.Format(“Il valore della variabile {0} è {1}”, “x”, x)
Nelle parentesi graffe, dopo l‟indice dell‟argomento, è possibile aggiungere una stringa di formattazione.
Le stringhe di formattazione utilizzabili sono le stesse del metodo toString( )
msg = String.Format(“Il valore della variabile {0} è {1:N4}”, “x”, x)
La classe Statica System.ControlChars
Elenco di costanti predefinite; Cr, Lf, CrLf, Tab, VerticalTab. Back, NullChar, Quote
Classe non supportata in C# dove si continuano ad utilizzare i vecchi caratteri di escape di ANSI C: \n, \r \ t \0
Il cast dei puntatori
A differenza di Visual Basic in C# non esistono le funzione CType e DirectCast, e nemmeno TryCast e TypeOf
ma la conversione di puntatori può essere fatta direttamente mediante il cast inline :
Object obj = new clsPerson();
clsPerson p = (clsPerson) obj;
Confronto fra puntatori: L‟operatore IS che verifica se un puntatore sta puntando ad un certo tipo di oggetto
Object obj = new clsTmp();
if (obj is clsPerson) {
clsPerson p = (clsPerson)obj;
}
pag 15Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
foreach (Control ctrl in this.Controls)
if (ctrl is Button) {
Button btn = (Button) ctrl; btn.Text = "";
}
Per i numeri si può usare: int n;
if (int.TryParse(txt.Text, out n) ) ……………
else console.writeln(“Campo non valido”);
Il metodo GetType( ) è invece presente in C#, sia sotto forma di metodo statico della classe Type :
Type x = Type.GetType("System.Int32");
MessageBox.Show(x.FullName);
sia come metodo di istanza:
if (ctrl.GetType().ToString() == "System.Windows.Forms.Button")
La classe MessageBox ed il metodo .Show()
MsgBoxResult MessageBox.Show(
messaggio As String, // Unico parametro obbligatorio
titolo As String, // Titolo visualizzato sulla barra blu del titolo.
pulsanti As MsgBoxButtons, // Pulsanti da visualizzare sulla form
icon As MsgBoxIcon // Icona da visualizzare sulla form
button As MsgBoxDefaultButton
)
MsgBoxButtons indica eventuali pulsanti aggiuntivi che possono essere posizionati all‟interno della finestra del
messaggio. Se non si specifica nulla viene automaticamente posizionato il solo pulsante di OK.
0 OKOnly Il solo pulsante OK [default]
1 OKCancel Pulsanti OK + Cancel
2 AbortRetryIgnore Pulsati Abort + Retry + Ignore
3 YesNoCancel Pulsati Si + No + Annulla
4 YesNo Pulsati Si + No
5 vbRetryCancel Pulsati Riprova + Annulla
MsgBoxIcon
16 Critical Cerchio con x interna
32 Question Nuvoletta con Punto Interrogativo
48 Exclamation Triangolo con Punto Esclamativo
64 Information Nuvoletta con i interna
MsgBoxDefaultButton
0 DefaultButton1 Il primo pulsante è preselezionato
256 DefaultButton2 Il secondo pulsante è preselezionato
512 DefaultButton3 Il terzo pulsante è preselezionato
pag 16Informatica - Classe Terza robertomana.it
Introduzione al linguaggio C#
Il programma rimane bloccato fino a che l‟utente non chiude la finestra clickando su uno dei pulsanti. MsgBox
restituisce come risultato una costante di tipo DialogResult che indica appunto quale pulsante è stato premuto..
DialogResult ris;
ris = MessageBox.Show ("Salvare le modifiche al documento corrente?",
"Microsoft Word",
MessageBoxButtons.YesNoCancel,
MessageBoxIcon.Exclamation );
if (ris == DialogResult.Yes) …………… //Significa che l‟utente ha premuto il pulsante SI
La funzione InputBox
In C# questa funzione non esiste in quanto è definita soltanto all‟interno della libreria Visual Basic.
In caso di necessità si può importare l‟intera libreria Visual Basic aggiungendo il Riferimento al progetto.
using Microsoft.VisualBasic;
string ris = Interaction.InputBox("Inserire un numero");
SINTASSI:
String InputBox(messaggio As String, titolo As String, default As String)
Titolo e Default sono facoltativi.
Messaggio rappresenta il messaggio all‟interno della finestra (es “Prego inserire il vostro Nome”)
Titolo rappresenta il titolo della finestra, cioè ciò che verrà scritto sulla barra blu del titolo.
Default indica un eventuale valore di default che comparirà a video nella casella di Input.
Se la finestra viene chiusa mediante il pulsante Cancel o la x della barra del titolo InputBox restituisce stringa vuota.
Gestione delle eccezioni strutturate
Una eccezione è una condizione inaspettata che si verifica durante l‟esecuzione di una applicazione e che, se non
viene gestita, ne arresta bruscamente l‟esecuzione (tipico Run Time Error).
Una eccezione può essere intercettata dalla procedura nella quale si è verificata. Se ciò non accade, l‟eccezione
viene sollevata al chiamante, che se vorrà potrà gestire l‟eccezione, e così via fino al main. Se nessuno intercetta
l‟eccezione, si verifica un Run Time Error con visualizzazione di un messaggio di errore.
L’oggetto System.Exception
Quando si verifica una eccezione, viene creato un oggetto Exception che, se non gestito, viene passato al
chiamante. Esistono però diversi tipi di oggetti Exception. Ad esempio:
le operazioni matematiche possono sollevare oggetti Exception del tipo OverflowException o
DivideByZeroException,
e funzioni possono sollevare eccezioni del tipo ArgumentOutOfRangeException.
Tutti i vari oggetti Exception dispongono comunque delle seguenti proprietà comuni:
Message [Read Only] Messaggio di descrizione dell‟errore
Source Nome dell‟oggetto in cui si è verificato l‟errore.
Se l‟errore si è verificato nella applicazione corrente, Source sarà stringa vuota
TargetSite Metodo che ha causato l‟errore.
HelpLink URL di una pagina di Help che descrive come recuperare l‟errore. Es: “pagina15.htm#Target2”
pag 17Puoi anche leggere
