Please enable JavaScript.
Coggle requires JavaScript to display documents.
LE STRUTTURE DATI
Le strutture dati permettono di organizzare,…
LE STRUTTURE DATI
Le strutture dati permettono di organizzare, memorizzare e gestire gli elementi di una collezione.
In C# esistono diverse strutture, tra cui LinkedList, List, Queue e Stack.
1) LISTE CONCATENATE (Linked Lists)
- Sono formate da elementi collegati tra loro, chiamati nodi.
- Ogni nodo contiene: data (valore memorizzato); link (collegamento al nodo successivo).
- Head: riferimento al primo nodo.
- L'ultimo nodo non ha un collegamento successivo.
- Hanno una dimensione variabile.
- Per raggiungere un elemento bisogna attraversare i nodi precedenti.
- In C# esiste LinkedList<T>, che utilizza collegamenti in entrambe le direzioni.
2) OPERAZIONI SULLE LISTE CONCATENATE
- Traversing: scorre la lista per leggere gli elementi.
- Appending: aggiunge un nodo alla fine.
- Prepending: aggiunge un nodo all'inizio.
- Insertion: inserisce un nodo in una posizione specifica.
- Deletion: elimina un nodo.
(L'inserimento e l'eliminazione avvengono modificando i collegamenti, senza spostare gli altri elementi).
3) LISTA DINAMICA (List<T>)
- È una lista basata su un array che può aumentare di dimensione.
- Permette di accedere direttamente agli elementi tramite indice.
- Count: indica il numero di elementi presenti.
- Capacity: indica quanti elementi può contenere prima di ridimensionarsi.
4) CODA (Queue<T>)
- Funziona secondo il principio FIFO (First-In, First-Out).
- Il primo elemento inserito è il primo a uscire.
- Viene utilizzata per code di stampa, messaggi e attività da elaborare.
5) PILA (Stack<T>)
- Funziona secondo il principio LIFO (Last-In, First-Out).
- L'ultimo elemento inserito è il primo a uscire.
- Viene utilizzata per annullare operazioni, ripristinarle e gestire chiamate ricorsive.
6) DIFFERENZE PRINCIPALI
- Array: dimensione stabilita alla creazione; accesso diretto tramite indice.
- LinkedList: dimensione variabile; elementi collegati tramite nodi; inserimenti ed eliminazioni senza spostamenti.
- List: array dinamico; accesso diretto tramite indice; inserimenti ed eliminazioni possono richiedere spostamenti.
- Queue: segue l'ordine FIFO; il primo elemento inserito esce per primo.
- Stack: segue l'ordine LIFO; l'ultimo elemento inserito esce per primo.
Differenza fondamentale: List<T> e LinkedList<T> non sono la stessa struttura. La prima utilizza un array dinamico, la seconda utilizza nodi collegati.
WINDOWS FORMS CON C# IN VISUAL STUDIO
- Windows Forms permette di creare applicazioni Windows con un'interfaccia grafica, utilizzando C# e Visual Studio.
- Le applicazioni contengono finestre, pulsanti, caselle di testo e altri elementi con cui l'utente può interagire.
1) CREAZIONE DEL PROGETTO
- Aprire Visual Studio e selezionare Create a new project.
- In alternativa: Continue without Code
-> File -> New -> Project.
- Selezionare il linguaggio C#.
- Scegliere la categoria Desktop.
- Selezionare Windows Forms App.
- Cliccare su Next, assegnare un nome e scegliere dove salvare il progetto.
- Selezionare il framework e cliccare su Create.
Visual Studio crea una finestra iniziale chiamata Form, che rappresenta l'interfaccia dell'applicazione.
2) PERSONALIZZAZIONE DELLA FINESTRA
Il pannello Properties (chiave inglese) permette di modificare le caratteristiche della finestra.
- Text: modifica il titolo della finestra.
- BackColor: modifica il colore dello sfondo.
- ForeColor: modifica il colore del testo.
- Dimensioni: si modificano trascinando i bordi della finestra.
3) ELEMENTI GRAFICI (TOOLBOX)
- Il Toolbox contiene gli strumenti per costruire l'interfaccia grafica.
- Si apre attraverso View -> Toolbox.
Elementi principali
- Label: visualizza un testo.
- TextBox: permette di inserire del testo.
- Button: crea un pulsante che esegue un'azione.
- CheckBox: permette di selezionare o deselezionare un'opzione.
Gli elementi si inseriscono trascinandoli nella finestra e possono essere spostati o ridimensionati.
4) SCRITTURA DEL CODICE C#
- Facendo doppio clic su un pulsante si apre il codice dell'evento Click.
- L'evento Click viene eseguito quando l'utente preme il pulsante.
- string: tipo di dato utilizzato per memorizzare testo.
- textBox1.Text: legge il testo inserito nella casella.
- MessageBox.Show(): mostra una finestra contenente un messaggio.
5) Esempio di codice
private void button1_Click(object sender, EventArgs e)
{
string text = textBox1.Text;
MessageBox.Show("Your name is " + text);
}
6) ESEMPIO DI APPLICAZIONE
L'applicazione chiede all'utente di inserire il proprio nome e lo visualizza in un messaggio.
Elementi utilizzati:
- Label: mostra la scritta Enter your name.
- TextBox: permette di scrivere il nome.
- Button: mostra la scritta Submit.
7) SALVATAGGIO ED ESECUZIONE
- File -> Save All: salva il progetto.
- Pulsante di esecuzione: avvia l'applicazione.
- L'utente può interagire con gli elementi grafici.
- Il codice C# gestisce le azioni e mostra i risultati.
Concetto fondamentale
Il Toolbox permette di costruire l'interfaccia, Properties di personalizzarla e il codice C# di renderla interattiva.
LE CODE (QUEUES)
Le code sono strutture dati che permettono di memorizzare e organizzare elementi secondo un ordine preciso.
Seguono il principio FIFO (First In, First Out): il primo elemento inserito è il primo a uscire.
In C# vengono gestite attraverso la classe Queue<T>.
1) STRUTTURA E FUNZIONAMENTO
- Rear o Tail: estremità dove vengono inseriti i nuovi elementi.
- Front o Head: estremità da cui vengono rimossi gli elementi.
- Gli elementi vengono elaborati nell'ordine di arrivo.
- Non è possibile accedere direttamente agli elementi tramite indice.
- Esempio: inserendo 2, 5 e 8, il primo elemento a uscire sarà 2. Il numero 5 diventerà il primo della coda.
2) OPERAZIONI PRINCIPALI
- Enqueue(): aggiunge un elemento alla fine.
- Dequeue(): rimuove e restituisce il primo elemento.
- Peek(): legge il primo elemento senza eliminarlo.
- TryDequeue(): prova a rimuovere il primo elemento senza generare errori se la coda è vuota.
- TryPeek(): prova a leggere il primo elemento senza eliminarlo.
- Clear(): elimina tutti gli elementi.
Attenzione: Dequeue() e Peek() generano un errore se la coda è vuota.
3) PROPRIETÀ E CONTROLLI
- Count: indica il numero di elementi presenti.
- IsEmpty: verifica se la coda è vuota.
- IsFull: verifica se la coda ha raggiunto la capacità massima, quando prevista.
In C#, Queue<T> non possiede direttamente i metodi IsEmpty e IsFull. Per verificare se è vuota si utilizza Count == 0.
4) COMPLESSITÀ DELLE OPERAZIONI
- O(1): tempo costante, indipendente dal numero di elementi.
- Enqueue(): O(1) ammortizzato.
- Dequeue(), Peek(), TryDequeue() e TryPeek(): O(1).
- Clear(): O(N), perché deve eliminare tutti gli elementi.
5) UTILIZZI PRINCIPALI
Le code vengono utilizzate per gestire richieste e operazioni in attesa.
- Stampanti condivise: organizzano i documenti da stampare.
- CPU: gestisce i processi in attesa di esecuzione.
- Messaggi: organizza i messaggi da elaborare.
- Attività asincrone: gestisce operazioni da eseguire successivamente.
- Buffer dati: conserva temporaneamente informazioni in attesa di elaborazione.
6) DIFFERENZA TRA QUEUE, STACK E LIST
- Queue: segue il principio FIFO. Il primo elemento inserito esce per primo.
- Stack: segue il principio LIFO. L'ultimo elemento inserito esce per primo.
- List: permette di accedere direttamente agli elementi tramite indice.
Differenza fondamentale: Queue e Stack seguono un ordine preciso di estrazione, mentre List permette una gestione più libera degli elementi.
GLI STREAM IN C#
- Gli stream sono flussi di dati che permettono di leggere e scrivere informazioni nei file.
- Servono a trasferire dati tra il programma e la memoria permanente.
- In C# si utilizza il namespace System.IO (Input/Output).
1) MEMORIA RAM E MEMORIA PERMANENTE
- RAM: memoria veloce ma volatile. I dati vengono persi quando il programma termina.
- Memoria permanente: conserva i dati anche dopo lo spegnimento del computer.
- Dispositivi: SSD, disco rigido e memoria USB.
- File: permettono di conservare le informazioni nel tempo.
2) FUNZIONAMENTO DEGLI STREAM
Uno stream è un canale che trasferisce dati tra il programma e un file.
- Scrittura (Output): Programma -> Stream -> File.
- Lettura (Input): File -> Stream
-> Programma.
- Gli stream permettono di trasferire i dati progressivamente.
- Possono gestire anche file di grandi dimensioni.
- Permettono di controllare modalità e posizione di accesso-
3) SCRITTURA DEI FILE (StreamWriter)
StreamWriter permette di scrivere testo all'interno di un file.
Operazioni principali:
- new StreamWriter(): apre o crea un file per la scrittura.
- WriteLine(): scrive una riga di testo.
- Close(): chiude lo stream.
- using: chiude e libera automaticamente lo stream al termine del blocco.
ESEMPIO
using (StreamWriter sw = new StreamWriter("studenti.txt"))
{
sw.WriteLine("Mario Rossi");
sw.WriteLine("Luca Bianchi");
}
4) LETTURA DEI FILE (StreamReader)
StreamReader permette di leggere il testo contenuto in un file.
Operazioni principali:
- new StreamReader(): apre un file per la lettura.
- ReadLine(): legge una riga alla volta.
- ReadToEnd(): legge tutto il contenuto del file.
- Close(): chiude lo stream.
- using: chiude automaticamente lo stream.
ESEMPIO
using (StreamReader sr = new StreamReader("studenti.txt"))
{
string testo = sr.ReadToEnd();
Console.WriteLine(testo);
}
5) FILESTREAM E FILEMODE
- FileStream permette di gestire un flusso di dati collegato a un file.
- FileMode stabilisce come il file deve essere aperto o creato.
Modalità principali:
- Open: apre un file esistente.
- Create: crea un file nuovo o sovrascrive quello esistente.
- OpenOrCreate: apre il file se esiste, altrimenti lo crea.
- Append: aggiunge dati alla fine del file.
ESEMPIO
FileStream fs = new FileStream(
"dati.dat",
FileMode.OpenOrCreate);
-
Metodi principali
- Add(): aggiunge un elemento alla fine.
- AddRange(): aggiunge più elementi.
- Insert(): inserisce un elemento in una posizione.
- Remove(): elimina un elemento specifico.
- RemoveAt(): elimina un elemento tramite indice.
- Contains(): verifica se un elemento esiste.
- Find(): cerca un elemento che rispetta una condizione.
- Sort(): ordina gli elementi.
- Clear(): svuota la lista.
Metodi principali
- Enqueue(): aggiunge un elemento in fondo.
- Dequeue(): rimuove e restituisce il primo elemento.
- Peek(): legge il primo elemento senza eliminarlo.
- TryDequeue(): prova a rimuovere il primo elemento senza generare errori se la coda è vuota.
- TryPeek(): prova a leggere il primo elemento senza eliminarlo.
- Clear(): svuota la coda.
- Count: indica il numero di elementi presenti.
Metodi principali
- Push(): aggiunge un elemento in cima.
- Pop(): rimuove e restituisce l'ultimo elemento inserito.
- Peek(): legge l'elemento in cima senza eliminarlo.
- TryPop(): prova a rimuovere l'elemento in cima senza generare errori se la pila è vuota.
- TryPeek(): prova a leggere l'elemento in cima senza eliminarlo.
- Clear(): svuota la pila.
- Count: indica il numero di elementi presenti.
Utilizzi principali
- Chiamate alle funzioni: gestiscono l'esecuzione e il ritorno delle funzioni.
- Ricorsione: gestiscono le funzioni che richiamano sé stesse.
- Undo/Redo: permettono di annullare o ripristinare operazioni.
- Compilatori: controllano che le parentesi nel codice siano bilanciate.
- Espressioni: aiutano a eseguire calcoli e analizzare formule.
- Navigazione: permettono di tornare alle operazioni precedenti.
Funzionamento
- L'utente inserisce il proprio nome.
- Preme il pulsante Submit.
- Il programma legge il nome e lo salva in una variabile.
- MessageBox.Show() visualizza il messaggio.
Esempio: inserendo Tizio, compare il messaggio Your name is Tizio.
ESEMPIO
try
{
using (StreamReader sr = new StreamReader("studenti.txt"))
{
string testo = sr.ReadToEnd();
}
}
catch (Exception ex)
{
Console.WriteLine("Errore: " + ex.Message);
}
Concetto fondamentale
- StreamWriter scrive nei file
- StreamReader legge dai file
- FileStream gestisce il flusso di dati
- using permette di chiudere correttamente gli stream
- try e catch aiutano a gestire gli errori.