Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

1 CORSO INFORMATICA C# Sommario 1.1 Analisi del…

  1. User

    1 CORSO INFORMATICA C# Sommario 1.1 Analisi del problema.......................................................................................................................... 3 1.2 Caratteristiche principali della pseudocodifica:................................................................................. 4 1.3 Il diagramma di flusso (flow chart)................................................................................................... 5 1.4 Che cosa è un linguaggio di programmazione................................................................................... 5 1.5 La differenza principale tra linguaggi................................................................................................ 6 1.6 Differenze tra HTML e linguaggi di programmazione:..................................................................... 6 1.7 IDE .................................................................................................................................................... 6 1.8 Caratteristiche principali di un IDE................................................................................................... 6 2 Operatori logici.......................................................................................................................................... 7 2.1 Gli operatori di confronto.................................................................................................................. 7 2.2 Operatori aritmetici e loro rappresentazione in C#............................................................................ 7 3 Introduzione............................................................................................................................................... 8 3.1 IL METODO MAIN.............................................................................................................................. 8 3.2 COMMENTI ........................................................................................................................................ 8 3.3 Concetti di base ................................................................................................................................. 9 3.4 Inizializzazione............................................................................................................................... 10 3.5 Tipi di dati ....................................................................................................................................... 10 4 Funzioni di Output................................................................................................................................... 11 4.1 Funzioni di Input ............................................................................................................................. 11 4.2 Differenze tra int.Parse() - Convert.ToInt32() e int.TryParse().................................................... 11 4.3 Convert.ToInt32 .............................................................................................................................. 12 4.4 Il costruttore if - else........................................................................................................................ 12 5 Istruzioni di iterazione............................................................................................................................. 13 5.1 Catene di if-else............................................................................................................................... 13 5.2 Il ciclo while .................................................................................................................................... 14 5.3 Il ciclo do......................................................................................................................................... 14 5.4 Il ciclo for ........................................................................................................................................ 15 5.5 Il costrutto switch ............................................................................................................................ 16 5.6 Casting............................................................................................................................................. 17 5.7 Caratteri di escape ........................................................................................................................... 17 5.8 Scope................................................................................................................................................ 18 5.8.1 Tipi di Scope:........................................................................................................................... 18 6 Funzioni e Procedure............................................................................................................................... 19 6.1 Caratteristiche principali delle funzioni: ......................................................................................... 19 6.2 Procedure......................................................................................................................................... 19 2 Introduzione alla 00P ..................................................................................................................................... 20 6.2.1 In sintesi: ................................................................................................................................. 20 6.2.2 Concetti Fondamentali dell'OOP............................................................................................. 20 7 Astrazione .............................................................................................................................................. 21 7.1 Costruttori........................................................................................................................................ 21 7.2 Overloading dei metodi ................................................................................................................... 21 7.3 Modificatori di accesso................................................................................................................. 22 7.4 L’incapsulazione.............................................................................................................................. 23 7.5 EREDITARIETA’........................................................................................................................... 23 8 Le interfacce ............................................................................................................................................ 25 8.1.1 Caratteristiche principali di un'interfaccia in C#: .................................................................... 25 8.1.2 Sintassi di un'interfaccia .......................................................................................................... 25 8.1.3 Implementazione di un'interfaccia........................................................................................... 26 8.1.4 Ereditarietà multipla ................................................................................................................ 27 8.1.5 Interfacce predefinite in C# ..................................................................................................... 27 8.1.6 Differenze tra interfacce e classi astratte ................................................................................. 27 8.1.7 Conclusione ............................................................................................................................. 27 9 Overloading degli operatori..................................................................................................................... 27 9.1 Come funziona l'overloading degli operatori .................................................................................. 28 9.2 Indicizzatore .................................................................................................................................... 28 9.2.1 Sintassi dell'indicizzatore ........................................................................................................ 28 10 File e directory..................................................................................................................................... 28 10.1 Leggere e scrivere file ..................................................................................................................... 30 10.2 Lista dei file di una directory........................................................................................................... 31 11 Espressioni Lambda......................................................................................................................... 31 11.1 Func ................................................................................................................................................. 31 11.2 Action .............................................................................................................................................. 31 11.3 Predicate .......................................................................................................................................... 32 11.3.1 Vantaggi di Lambda, Func, Action e Predicate .................................................................. 32 3 1.1 Analisi del problema Ognuno di noi, nel corso della giornata, incontra molti problemi, semplici o complessi, da risolvere. Risolvere un problema significa compiere delle azioni (elaborazione) su oggetti (di natura concreta o astratta), detti dati iniziali, modificandone lo stato per raggiungere lo scopo voluto (ossia i risultati o dati finali). Colui che si propone di risolvere il problema, cioè il risolutore, deve svolgere un'attività creativa nella ricerca della soluzione al problema e, avvalendosi di un patrimonio di conoscenze precedentemente acquisite, deve:

    1. interpretare l'enunciato del problema;
    2. evidenziare i dati che l'enunciato fornisce (dati iniziali);
    3. ricercare tutte le azioni (operazioni) da compiere sui dati e collegarle logicamente in funzione del raggiungimento dei risultati o dati finali;
    4. eseguire nell'ordine le operazioni descritte al punto 3;
    5. verificare i risultati. L'attività che il risolutore svolge per realizzare i punti 1), 2), 3) prende il nome di analisi del problema. Quando il risolutore realizza il punto 4), cioè quando esegue le azioni descritte nel punto 3), assume il ruolo di esecutore Spesso, il risolutore e l'esecutore sono la stessa persona ma, a volte, non è così: può presentarsi il caso che il risolutore demandi l'esecuzione della soluzione del problema a un'altra persona oppure a un esecutore automatico quale, per esempio, un calcolatore elettronico. In questo caso, il risolutore deve preparare un'accurata descrizione del procedimento risolutivo costituito da un insieme di comandi da impartire all'esecutore. Tale descrizione è, naturalmente, condizionata dalle caratteristiche dell'esecutore. Il risolutore deve sapere:
    • quale linguaggio comprende l'esecutore;
    • quali sono le azioni operative e logiche che l'esecutore sa eseguire.
    • La descrizione della risoluzione del problema prende il nome di algoritmo
    • Il termine algoritmo si riferisce ad un insieme di istruzioni o regole da seguire per risolvere un problema. Di fatto, gli algoritmi sono utilizzati in quasi tutti i settori, dalla finanza alla sanità ai trasporti. La risoluzione del problema deve soddisfare le seguenti condizioni:
    1. contenere il nome di tutti gli oggetti da manipolare (dati iniziali);
    2. contenere la descrizione di un insieme finito delle azioni effettivamente eseguibili che devono operare sugli oggetti;
    3. ogni azione descritta deve svolgersi in un tempo determinato, cioè con un inizio e una fine;
    4. le azioni sono descritte in sequenza logicamente strutturata e, quindi, devono essere specificate le eventuali condizioni affinché a un'azione ne segua una e non un'altra;
    5. tutte le azioni necessarie devono essere presenti e ogni azione deve essere interpretabile in un unico modo (di completezza e univocità). Per chiarire quanto esposto, diamo un esempio di algoritmo che sia familiare a ognuno di noi. 4 Esempio cuocere la pasta: La pseudocodifica, o pseudocodice, è una rappresentazione informale e semplificata di un algoritmo o di un programma informatico, scritta in un linguaggio che combina elementi del linguaggio naturale (come l'italiano o l'inglese) e della programmazione, ma senza aderire rigorosamente alla sintassi di alcun linguaggio di programmazione specifico. L'obiettivo della pseudocodifica è descrivere in modo chiaro e conciso i passaggi logici di un algoritmo, rendendoli comprensibili sia per chi ha una formazione informatica che per chi non conosce i dettagli di un particolare linguaggio di programmazione. 1.2 Caratteristiche principali della pseudocodifica:  Leggibilità: È destinata a essere facilmente compresa dagli esseri umani piuttosto che interpretata da un computer.  Non vincolata alla sintassi formale: Può mescolare espressioni di linguaggio naturale e istruzioni simili a quelle dei linguaggi di programmazione.  Focus sulla logica: Si concentra sulla logica e sui passaggi dell'algoritmo, piuttosto che sui dettagli implementativi (come la gestione della memoria o la sintassi esatta).  Versatilità: Può essere utilizzata come strumento di comunicazione tra sviluppatori, o come guida preliminare prima della scrittura del codice vero e proprio. Esempio di pseudocodifica: determinare il maggiore fra due numeri INIZIO Leggi il valore di A e B Se (A è maggiore di B) ALLORA: Stampa "A è maggiore di B" ALTRIMENTI: Stampa "B è maggiore o uguale ad A" FINE Questo esempio descrive in maniera chiara e comprensibile un controllo condizionale senza usare la sintassi di un linguaggio di programmazione specifico. Pseudocodifica Il diagramma di flusso ( flow chart ) INIZIO
    1. Metti l’acqua nella pentola
    2. Metti un cucchiaio di sale nella pentola
    3. Accendi il fornello della cucina
    4. Metti la pentola sul fornello
    5. SE l’acqua bolle a. ALLORA metti la pasta nella pentola per 10min b. ALTRIMENTI aspetti altri 5 min e ripeti il punto 5)
    6. Spegni il fornello e scola la pasta FINE 5 L'insieme di tutti i problemi che vengono risolti dallo stesso algoritmo costituisce una classe di problemi. La fase di acquisizione dei dati viene anche definita fase di input o di immissione. La fase di presentazione dei risultati prende il nome di output o di emissione. In un computer, lo strumento attraverso il quale avviene la maggior parte delle operazioni di input è la tastiera (standard input) mentre l'unità più utilizzata per la presentazione dei risultati è il video (standard output); questo processo è schematizzato nella figura seguente. Il risultato dell'elaborazione compiuta dall'algoritmo è costituito da un insieme di uno o più valori, detti dati di output, che vengono messi a disposizione all'esterno visualizzandoli sul monitor o scrivendoli su file o su carta. Si tratta della fase in cui il programma comunica i dati finali, ottenuti grazie all'elaborazione. Quando si descrive un algoritmo, si indica la fase di emissione dei dati di output con istruzioni del tipo "scrivi" oppure "visualizza", seguite dal nome dei dati che vengono comunicati all'utente. Può succedere che, per ottenere i dati di output a partire dai dati di input, sia necessario passare attraverso risultati intermedi. Tali dati non sono né il frutto di operazioni di acquisizione né sono utilizzati in operazioni di emissione, ma sono dati temporanei che si ottengono nel corso dell'elaborazione. Essi prendono il nome di variabili Una variabile è una coppia (nome, valore) dove:
    • il nome è l'identificatore associato alla variabile (esso rimane costante durante l'esecuzione dell'algoritmo);
    • il valore è il contenuto associato alla variabile in un certo istante dell'esecuzione dell'algoritmo (esso può variare durante l'esecuzione dell'algoritmo). I dati di input sono i valori iniziali che servono all'algoritmo per elaborare la soluzione del problema. Le variabili sono dati non provenienti dall'esterno, bensì rappresentano risultati intermedi ottenuti durante l'elaborazione. I dati di output costituiscono il risultato delle operazioni effettuate dall'algoritmo. Essi vengono resi disponibili all'esterno mediante visualizzazione o stampa. 1.3 Il diagramma di flusso (flow chart) Una tradizionale tecnica di rappresentazione è quella del diagramma a blocchi (DAB). Questa tecnica nota anche come diagramma di flusso o flow-chart secondo la terminologia anglosassone si basa su una rappresentazione grafica della sequenza di operazioni dell'algoritmo. Un algoritmo viene strutturato in blocchi di istruzioni ciascuno dei quali, a seconda della propria funzione, viene rappresentato mediante una particolare simbologia. Linee orientate (connettori di flusso) collegano tra di loro i vari blocchi per indicare l'ordine di esecuzione delle operazioni dell'algoritmo Esistono cinque tipi base di blocchi elementari descritti e rappresentati graficamente nella TABELLA 2. 1.4 Che cosa è un linguaggio di programmazione Un linguaggio di programmazione è un insieme di regole e simboli che permette di scrivere istruzioni comprensibili da un computer per eseguire compiti specifici. Consente ai programmatori di comunicare con il sistema informatico, traducendo le idee e le soluzioni in un formato che il computer può interpretare ed eseguire. 6 Caratteristiche principali:
    1. Sintassi: Le regole che determinano la struttura corretta delle istruzioni.
    2. Semantica: Il significato delle istruzioni e delle strutture sintattiche.
    3. Compilazione o interpretazione: Il codice scritto viene tradotto in codice macchina tramite un compilatore (che genera un eseguibile) o un interprete (che esegue il codice direttamente). I linguaggi di programmazione possono seguire diversi modelli, come:  Procedurale: Basato su sequenze di istruzioni (es. C).  Orientato agli oggetti (OOP): Organizzato attorno a "oggetti" e classi (es. Java, Python,C#).  Dichiarativo: Descrive cosa fare, non come farlo (es. SQL). 1.5 La differenza principale tra linguaggi La differenza principale tra linguaggi di programmazione ad alto livello e linguaggi di programmazione a basso livello riguarda il loro grado di astrazione dall'hardware e la vicinanza al linguaggio comprensibile dall'uomo o dal computer. Caratteristica Linguaggi a basso livello Linguaggi ad alto livello Astrazione Molto bassa (vicino all'hardware) Alta (vicino al linguaggio umano) Portabilità Bassa (legata all'hardware) Alta (indipendente dall'hardware) Efficienza Molto alta Relativamente bassa Facilità d'uso Difficile Facile Gestione della memoria Manuale Automatica (nella maggior parte) Esempi Assembly, linguaggio macchina Python, Java, C#, Ruby, etc. L'HTML (HyperText Markup Language) non è tecnicamente un linguaggio di programmazione, ma un linguaggio di markup. Viene utilizzato per creare e strutturare il contenuto delle pagine web. 1.6 Differenze tra HTML e linguaggi di programmazione:  Linguaggi di programmazione: Come Python, Java o C, questi permettono di scrivere istruzioni che il computer può eseguire, come calcoli, gestione di dati e decisioni condizionali.  HTML: Definisce la struttura e il layout di un documento, specificando come i contenuti (testo, immagini, link, ecc.) devono essere visualizzati in un browser web. HTML non esegue logiche o calcoli, ma solo descrive il contenuto. I linguaggi di programmazione sono essenziali per lo sviluppo di software, applicazioni e sistemi informatici. 1.7 IDE Un IDE (Integrated Development Environment) è uno strumento essenziale per gli sviluppatori software, progettato per semplificare e ottimizzare il processo di scrittura, test e debugging del codice. Ecco una panoramica di cosa offre un IDE e alcuni dei più noti nel campo dell'informatica: 1.8 Caratteristiche principali di un IDE
    4. Editor di codice: Fornisce un'area per scrivere e modificare il codice sorgente con funzionalità come evidenziazione della sintassi, autocompletamento e suggerimenti di codice. 7
    5. Compilatore/Interprete: Permette di trasformare il codice sorgente in un formato eseguibile (compilazione) o di eseguire il codice direttamente (interpretazione).
    6. Debugging: Strumenti per identificare e correggere errori nel codice. Include funzionalità come punti di interruzione (breakpoints), ispezione delle variabili e controllo del flusso di esecuzione. 2 Operatori logici Gli operatori logici sono delle congiunzioni utili per legare insieme due o più condizioni fra loro.
    • Definizione: Una condizione è una qualsiasi affermazione che può essere vera o falsa Gli operatori logici più utilizzati sono: OR ("o" inclusivo), AND ("e" congiunzione),NOT ("non" negazione)
    • Le tabelle delle verità: Ogni operatore logico può essere descritto per mezzo di una tabella delle verità che assegna ad ogni combinazione dei valori di input i corrispondenti valori agli output.
    • Per ogni funzione esiste un'unica tabella delle verità che la rappresenta e viceversa. OPERATORE AND A B A && B FALSO FALSO FALSO FALSO VERO FALSO VERO FALSO FALSO VERO VERO VERO OPERATORE OR A B A || B FALSO FALSO FALSO FALSO VERO VERO VERO FALSO VERO VERO VERO VERO OPERATORE NOT A ! A FALSO VERO VERO FALSO 2.1 Gli operatori di confronto Gli operatori di confronto confrontano due valori e riportano un risultato Vero o Falso. (Tali espressioni sono talvolta chiamate espressioni booleane.) Dal punto di vista matematico, il risultato Vero equivale a 1 e Falso equivale a 0. Simbolo Nome Definizione == Uguale a Vero se gli elementi sono uguali != Diverso da Vero se gli elementi non sono uguali

    Maggiore di Vero se il valore a sinistra è maggiore del valore a destra < Minore di Vero se il valore a sinistra è minore del valore a destra = Maggiore o uguale a Vero se il valore a sinistra è maggiore o uguale al valore a destra <= Minore o uguale a Vero se il valore a sinistra è minore o uguale al valore a destra 2.2 Operatori aritmetici e loro rappresentazione in C# Definizione Simbolo Addizione + Sottrazione - Moltiplicazione * Divisione / Modulo(resto) % Precedenza () 8 3 Introduzione Il framework .NET introdotto da Microsoft nel luglio dell’anno 2000, costituisce forse una delle più grandi novità nel campo dello sviluppo del software da parecchi anni a questa parte, e C# ne rappresenta la punta di diamante, il linguaggio di programmazione principe. A proposito, C# si pronuncia C sharp. Con C# potremo sviluppare applicazioni desktop, pagine internet, applicazioni per l’accesso ai dati, o ancora per i telefoni e i palmari di ultima generazione, e chi più ne ha più ne metta, insomma ogni campo applicativo è coperto. CIAO MONDO //primo programma C# using System; class CiaoMondo { public static void Main() { Console.WriteLine("Ciao mondo"); } } 3.1 IL METODO MAIN Il metodo principale dell’applicazione, cioè il suo punto di ingresso, il punto dal quale l’applicazione comincia la sua esecuzione è il Main(). Il metodo Main può essere implementato in diverse maniere, prestando sempre attenzione all’iniziale maiuscola (C# è un linguaggio case-sensitive, dunque main è diverso da Main), ed esso può restituire un valore intero oppure nessun valore, inoltre può accettare dei parametri in ingresso. Sebbene nell’esempio precedente abbiamo usato il modificatore public per il metodo Main, non ha nessuna importanza se esso sia presente o meno, anzi funzionerebbe tutto quanto anche mettendo private. Il metodo viene in ogni caso richiamato dall’esterno del programma per consentirne appunto l’avvio. I possibili modi di scrivere il metodo sono, tralasciando il modificatore, i seguenti: static void Main() {…} static void Main(string[] args) {…} static int Main() {…} static int Main(string[] args) {…} 3.2 COMMENTI I commenti all’interno del codice sono di importanza fondamentale, sia quando esso dovrà essere usato da altre persone, ma anche per lo sviluppatore stesso, che riprendendo un suo vecchio programma riuscirà ad orientarsi e a capire sicuramente meglio e con meno fatica, quello che aveva scritto. C# permette due modalità di inserimento di un commento all’interno del codice. Con la prima è possibile inserire un commento su una linea sola: //un commento su una linea mentre qualora sia necessario inserire commenti più lunghi, che si estendano cioè su più righe viene usata la seconda modalità, in cui il commento è delimitato fra le sequenze /* e /, ad esempio / questo è un commento su tre linee */ 9 3.3 Concetti di base Dichiarazioni di variabili In C#, come in ogni linguaggio di programmazione, le dichiarazioni consentono la definizione degli elementi che costituiranno il programma. Le dichiarazioni sono necessarie, in quanto servono ad assegnare ad ogni elemento del programma un nome univoco, perlomeno nel proprio campo d’azione o scope. Ad esempio scrivendo l’istruzione UnTipo numero; abbiamo dichiarato una variabile di tipo UnTipo, cioè abbiamo prenotato e delimitato una zona di memoria adeguata a contenere un UnTipo. Diamo un’occhiata a degli esempi più reali, anche se ancora non abbiamo parlato dei tipi di C#. int i; float f; string bt; bool stato; le 4 istruzioni precedenti dichiarano quattro variabili, i, f , stato e bt, di tipo rispettivamente intero, reale e stringa e booleano. Queste dichiarazioni indicano inoltre al compilatore di allocare uno spazio di memoria adeguato a contenere quattro dati dei relativi tipi. Ad esempio, come vedremo più avanti, scrivendo: i=10; Abbiamo inserito nell’area di memoria identificato da i il valore 10. Per mezzo delle variabili potremo in seguito accedere alle aree di memoria in cui sono contenuti i dati veri e propri. Esistono naturalmente delle regole che definiscono quali nomi sono leciti, quali invece non è possibile utilizzare. In generale un identificatore è una sequenza di caratteri, sia lettere che numeri, ma che deve iniziare per lettera, oppure, come nella tradizione C, con il carattere _ (underscore). Ad esempio sono validi come identificatori di variabile i seguenti: _identificatore1 identificatore_2 ident_ficatore_2 Sottolineiamo inoltre che C# è un linguaggio case-sensitive, cioè esso distingue le lettere maiuscole dalle minuscole, quindi degli identificatori come i seguenti sono ben distinti e tutti leciti: Identificatore IDENTIFICATORE IdEnTiFiCaToRe 10 3.4 Inizializzazione Non basta dichiarare una variabile, prima di usarla dobbiamo assegnarle un valore, cioè dobbiamo riempire l’area di memoria che essa identifica. Quando assegniamo il valore alla variabile per la prima volta, questo processo si chiama inizializzazione della variabile, mentre in genere viene detto assegnazione, se stiamo dando alla variabile un nuovo valore. L’inizializzazione o l’assegnazione, si effettuano con l’utilizzo dell’operatore di assegnazione =. int nRuote; //dichiarazione nRuote=4; //inizializzazione float fTemp=36.2; //dichiarazione ed inizializzazione fTemp=38.5; //assegnazione di un nuovo valore La variabile nRuote viene inizializzata al valore 4, la variabile fTemp invece viene prima inizializzata a 36.2 e successivamente viene ad essa assegnato il nuovo valore 38.5. 3.5 Tipi di dati Nella tabella seguente vengono riassunti i tipi di dati primitivi. Tipo di dato C# Dim. (byte) Val. minimo Val. massimo sbyte 1 -128 127 byte 1 0 255 short 2 -32,768 32,767 ushort 2 0 65,535 int 4 -2,147,483,648 2,147,483,647 uint 4 0 4,294,967,295 long 8 -9,223,372,036,854,775,808 9,223,372,036,854,775,807 ulong 8 0 18,446,744,073,709,551,615 char 2 0 65,635 float 4 -3.4e38 -1.5e-45 double 8 -1.7e308 -5.0e-324 decimal 16 +/-1.0e-28 +/-7.9e28 bool 1 false (0) true (1)  I tipi di dati sbyte, byte, short, ushort, int, uint, long e ulong, sono adatti a contenere numeri interi.  I tipi di dati float, double e decimal, sono adatti a contenere numeri decimali. Il float e il double memorizzano numeri nel formato mantissa e esponente a base 2, mentre il decimal memorizza numeri nel formato mantissa e esponente a base 10.  I valori con virgole sono sempre double; i valori senza virgole sono sempre int. Questa regola vale sempre eccetto nel caso che dopo il numero sia indicato un suffisso.  Il float ha una precisione di circa 7 cifre decimali. Per utilizzarlo deve essere seguito da 'F' o 'f': float x = 3.5F // oppure float x = 3.5f  Il double ha una precisione da 14 a 16 cifre decimali. Per utilizzarlo deve essere seguito da 'D' o 'd' o niente perché un decimale per default è un double: double x = 3.1415926587412536D // oppure double x = 3.1415926587412536d 11  Il decimal ha una precisione da 28 a 29 cifre decimali. Per utilizzarlo deve essere seguito da 'M' o 'm': decimal valore = 1234.5M // oppure decimal valore = 1234.5m  Elenco di tutti i suffissi:

    • int: nessuno
    • uint: u, U
    • long: l, L
    • ulong: ul, Ul, uL, UL, lu, Lu, lU, LU
    • float: f, F
    • double: nessuno, d, D
    • decimal: m, M 4 Funzioni di Output Le funzioni Console.Write() è utilizzata per gestire l'output da console. Console.Write() Questa funzione scrive un testo nella console, senza andare a capo. Puoi usarla per visualizzare stringhe o altri tipi di dati. Console.Write("Ciao, "); Console.Write("come stai?"); //Ciao, come stai? Sulla stessa riga Una versione leggermente diversa è Console.WriteLine(), che scrive il testo e aggiunge automaticamente un a capo alla fine. Console.WriteLine("Ciao,"); // visualizza su una riga Ciao Console.WriteLine("come stai?");// visualizza sulla riga successiva Come stai? 4.1 Funzioni di Input La funzione Console.ReadLine() legge l'input dell'utente dalla console fino a quando non viene premuto Invio. Il testo inserito viene restituito come una stringa. Per questa caratteristica della funzione di input ReadLine() che acquisisce il dato come stringa bisogna utilizzare delle funzioni che trasformino il dato in input in numerico. La funzione int.Parse() in C# viene utilizzata per convertire una stringa che rappresenta un numero in un valore di tipo int (intero). È molto utile quando ricevi input da console (che è sempre una stringa) e vuoi convertirlo in un numero per eseguire operazioni aritmetiche o altre elaborazioni numeriche. string numeroStringa = "123"; int numeroIntero = int.Parse(numeroStringa); Console.WriteLine(numeroIntero); // Output: 123 4.2 Differenze tra int.Parse() - Convert.ToInt32() e int.TryParse() In C#, int.Parse, Convert.ToInt32 e int.TryParse sono metodi utilizzati per convertire una stringa in un intero (int), ma differiscono nel loro comportamento e nella gestione degli errori. Ecco un confronto tra i tre: Dettagli importanti su int.Parse(): Input valido: La stringa deve rappresentare correttamente un numero intero. Se la stringa contiene caratteri non numerici o è vuota, si verificherà un'eccezione (errore non gestito) 12 Alternativa: int.TryParse() per evitare le eccezioni, puoi usare int.TryParse(), che restituisce un booleano (true o false) in base al successo della conversione e non genera eccezioni. string input ; int risultato; input=ConsoleReadLine() bool successo = int.TryParse(input, out risultato); if (successo) { Console.WriteLine("Conversione riuscita: " + risultato); } else { Console.WriteLine("Conversione fallita."); } 4.3 Convert.ToInt32 Se la stringa è null, restituisce 0. Se la stringa non è un numero valido, genera un'eccezione Riepilogo  int.Parse e Convert.ToInt32 generano eccezioni in caso di errore, mentre int.TryParse restituisce semplicemente false.  Usa int.TryParse per un controllo sicuro e senza eccezioni quando non sei sicuro della validità della stringa, mentre int.Parse e Convert.ToInt32 sono utili quando sei certo che la stringa sia valida o quando vuoi gestire esplicitamente le eccezioni. 4.4 Il costruttore if - else Il modo più comune per controllare il flusso di esecuzione di un programma è quello di utilizzare il costrutto di selezione condizionale if/else. Il costrutto if/else può essere utilizzato in due maniere. Nella prima, l’if è seguito da una condizione booleana racchiusa fra parentesi, e solo se essa è vera, quindi solo se assume valore true, viene eseguito il blocco successivo. if( espressione di condizione ) { //ALLORA(true) Blocco_istruzioni } Il blocco di istruzioni può essere sia una istruzione semplice seguita da un punto e virgola, oppure un blocco di istruzioni racchiuso fra parentesi graffe. Il secondo modo è quello che prevede l’utilizzo della parola chiave else. Se l’espressione booleana dell’if non è vera, cioè non assume valore true, verrà eseguito il blocco o l’istruzione semplice che segue l’else. if(espressione condizionale) { //ALLORA(true) Blocco_istruzioni } else { //ALTRIMENTI(false) Blocco_istruzioni } I costrutti if/else possono essere annidati, cioè all’interno di un ramo if o di un ramo else possono essere inseriti altri costrutti if o if/else. In tali casi è opportuno ricordare che l’else si riferisce sempre all’if immediatamente precedente, a meno che non si utilizzino le parentesi graffe per delimitare i blocchi. Ad esempio di IF/ELSE annidati: if(x==0){ if(y==0){ Console.WriteLine(“ramo if”); } else{ Console.WriteLine(“ramo else”); } } 13 5 Istruzioni di iterazione Le istruzioni di iterazione hanno lo scopo di eseguire ripetutamente un determinato blocco di istruzioni, formato eventualmente anche da una sola istruzione. Esse dunque permettono di eseguire più cicli attraverso uno stesso blocco di codice, un tipico esempio è quello in cui si esegue un ciclo per leggere o scrivere i diversi elementi di un vettore. 5.1 Catene di if-else Una catena di if si ha quando tanti if-else si annidano ripetutamente e in ogni ramo “falso” c’è una sola istruzione: la if-else annidata anche se a sua volta contiene altre istruzioni, è comunque considerata una sola istruzione. È possibile omettere le parentesi nel ramo else. È conveniente rimuovere l’indentazione e ricordarsi dell’else finale. Consideriamo il seguente diagramma di flusso: La codifica in C# per quello che abbiamo detto circa le strutture di selezione annidate dovrebbe essere: if(a>0) { //Istruzioni_A} else { if (b>0) { //Istruzioni_B } else { if (c>0) { //Istruzioni_C } else { //Istruzioni_D } } } ma riconoscendo nella struttura una catena di if-else possiamo riscriverla in modo più sintetico in questo modo: if (a > 0) { //Istruzioni_A } else if (b > 0) { //Istruzioni_B } else if (c > 0) { //Istruzioni_C } else { //Istruzioni_D} 14 Questo meccanismo di annidamento o di inserimento in cascata utilizzando una selezione semplice ad una via o a due vie, piuttosto che l’utilizzo di catene di if-else, può essere ripetuto quante volte si vuole per realizzare l’algoritmo di risoluzione del problema.Vedremo con degli esempi applicativi l’applicazione di tale metodologia, prima però dobbiamo parlare di espressioni logiche, operatori logici, operatori relazionali o di confronto per costruire le condizioni da inserire nell’istruzione if. 5.2 Il ciclo while Il costrutto while permette di eseguire un blocco di istruzioni zero o più volte in base al valore di un’espressione booleana, secondo la seguente sintassi: Pseudocodifica MENTRE (condizione){ blocco codice } FINE MENTRE Linguaggio C# while(espressione condizionale) {//ripeti blocco_istruzioni } Fino a quando l’espressione condizionale restituisce valore true, il blocco istruzioni verrà eseguito. È dunque necessario, per uscire dal ciclo while, che l’espressione ad un certo punto diventi false, oppure che all’interno del ciclo while ci sia un’istruzione break, che fa saltare l’esecuzione alla fine del ciclo while, cioè all’istruzione immediatamente successiva, o comunque al di fuori di esso: int i=0; while(i<10)// Esce dal ciclo solo quando la i vale 10 ATTENZIONE !!! { Console.WriteLine(“i={0}”,i); // Stampa i valori da 0 a 9 contenuti nella variabile i i=i+1; //incrementa di un unità la i } /L’esempio precedente esegue il blocco fra parentesi graffe fino a che il valore della variabile i non sia pari a 10, per tale valore infatti l’espressione i<10 diventa false./ Come detto prima è possibile anche terminare il ciclo con un break, dunque anche da un ciclo while la cui espressione di valutazione sia sempre true, come nel caso seguente, è possibile uscire. int i=0; while(true) { Console.WriteLine(“i={0}”,i); i=i+1; if(i==8) break; } 5.3 Il ciclo do Il ciclo do è analogo al precedente, con l’unica differenza che il blocco di istruzioni incorporato viene eseguito almeno una volta, in quanto l’espressione booleana viene valutata alla fine del primo ciclo. A questo punto, se l’espressione assume valore true, si esegue un nuovo ciclo, altrimenti si esce da esso. int i=10; do { Console.WriteLine("i={0}",i); i=i-1;int i=10; do { Console.WriteLine("i={0}",i); i=i-1; } while(i>0); /Il valore di i è 10 in partenza, ciò nonostante il ciclo viene eseguito ugualmente e stampa il valore di i./ 15 Un esempio utile verificare se il valore inserito e conforme alle richieste del problema. Come ad esempio che il valore inserito sia maggiore di zero. int i=0; do { Console.WriteLine("Inserisci un valore per i: "); i= Convert.ToInt32(Console.ReadLine()); if (i<=0) { Console.WriteLine("Hai inserito un valore minore/uguale a zero"); } }while(i<=0); 5.4 Il ciclo for Il ciclo for è uno dei costrutti più comuni in qualsiasi linguaggio di programmazione, e anche nella pseudocodifica segue una struttura molto simile. Viene utilizzato per ripetere una serie di istruzioni un numero predefinito di volte. In pseudocodifica, un ciclo for può essere descritto nel seguente modo generale: Per i da valore_iniziale a valore_finale fai { // Blocco di istruzioni da eseguire } FinePer  i: Variabile contatore che viene incrementata o modificata ad ogni iterazione.  valore_iniziale: Il valore da cui la variabile contatore parte.  valore_finale: Il valore massimo (o minimo) che la variabile contatore può assumere, prima di terminare il ciclo.  FinePer: Termina il ciclo for. In alcuni linguaggi si utilizza anche end for o simili. In linguaggio ci C# for (inizializzazione; condizione; incremento){ // blocco di codice da eseguire }  inizializzazione: Viene eseguita una sola volta, prima dell'inizio del ciclo. Di solito viene utilizzata per dichiarare e inizializzare la variabile di controllo.  condizione: La condizione viene valutata prima di ogni iterazione. Se è true, il ciclo continua; se è false, il ciclo si interrompe.  incremento: Viene eseguito alla fine di ogni iterazione, e di solito viene usato per aggiornare la variabile di controllo (come l'incremento di un contatore). Esempio for (int i = 0; i < 5; i++) { Console.WriteLine("Iterazione numero: " + i); } 16 5.5 Il costrutto switch Se è necessario effettuare una scelta fra diversi alternativi percorsi di esecuzione, e tale scelta può essere basata sul valore assunto a runtime da una variabile di un tipo intero o string, allora è possibile usare il costrutto switch. La sintassi dello switch è la seguente: switch(espressione) { case costante1: blocco_istruzioni break; case costante2: blocco_istruzioni; break; default: blocco_istruzioni; break; } L’espressione all’interno delle parentesi viene valutata, e se il suo valore corrisponde ad una delle costanti dei case, il flusso del programma salta al case corrispondente, del quale viene eseguito il blocco distruzioni, fino a raggiungere una necessaria istruzione di salto. Se è presente una label default, e la valutazione dell’espressione produce un risultato non contemplato dalle costanti dei case, il flusso va alla label di default, se tale label invece non è presente il flusso va alla fine dello switch. Tipicamente l’istruzione di salto che chiude un blocco case è l’istruzione break, che fa uscire il programma dal costrutto switch. Esempio C# switch(x) { case 0: Console.WriteLine(“x è nulla”); break; case 1: Console.WriteLine(“x è 0 oppure 1”); break; default: Console.WriteLine(“x è diverso da 0 e 1”); break; } Tutti i case devono essere chiusi da un break; int myValue=4; switch(myValue) { case <= 0: Console.WriteLine("Valore minore di 0"); break; case > 0 and <= 10: Console.WriteLine("Valore compreso 1 e 10 "); break; default: Console.WriteLine("Valore maggiore di 10"); break; } switch (myValue) { case 1 or 2 or 3: Console.WriteLine("Valore 1 o 2 o 3"); break; case 4 or 5 or 6: Console.WriteLine("Valore 4 o 5 o 6"); break; default: // Do stuff break; } 17 5.6 Casting In C#, il casting è il processo di conversione di un tipo di dato in un altro. Ci sono due principali forme di casting: casting esplicito e casting implicito.
    • Casting Implicito: Il casting implicito avviene quando non c'è perdita di dati. Questo è comune con i tipi numerici più piccoli a quelli più grandi, come da int a long. Esempio: int num = 10; long bigNum = num; // Casting implicito, non c'è perdita di dati
    • Casting Esplicito: Il casting esplicito è necessario quando si cerca di convertire un tipo di dato che potrebbe comportare una perdita di dati. Si utilizza l'operatore di casting (ovvero il tipo di destinazione tra parentesi). Esempio double pi = 3.14; int intPi = (int)pi; // Casting esplicito, intPi sarà 3 5.7 Caratteri di escape In C#, i caratteri di escape sono utilizzati per rappresentare caratteri speciali all'interno delle stringhe. Questi caratteri iniziano con una barra inversa () e vengono utilizzati per rappresentare simboli o sequenze che altrimenti non potrebbero essere scritti direttamente. Esempio //dopo aver stampato sullo schermo "OGGI E’ UNA BELLA GIORNATA" va a capo Console.WriteLine("OGGI E\’ UNA BELLA GIORNATA"); //dopo aver stampato sullo schermo "OGGI E’ UNA BELLA GIORNATA" va a capo ANCHE QUESTA pur utilizzando write Console.Write("OGGI E\’ UNA BELLA GIORNATA\n"); //in questo caso si riesce grazie ad " a poter inserire degli apici doppi nel testo e non scambiarli per quelli di inizio e fine stringa Console.WriteLine("Ciao "Mondo""); //-> Ciao "Mondo" Sequenza di escape Nome carattere ' Virgoletta singola \ Barra inversa () " Virgoletta doppia \a Avviso \b Backspace \n Nuova riga(Line Feed LF ) \t Tabulazione orizzontale 18 5.8 Scope Nell'ambito dell'informatica, il concetto di variabili e il loro "scope" (ambito) si riferisce alla visibilità e alla durata delle variabili in un programma. In altre parole, lo scope determina da quale parte del codice una variabile è accessibile e quando viene creata e distrutta. Questo concetto è cruciale in molti linguaggi di programmazione per evitare errori e gestire efficientemente le risorse. Esistono diversi tipi di scope per le variabili, che variano leggermente a seconda del linguaggio di programmazione, ma i concetti principali sono generalmente comuni. 5.8.1 Tipi di Scope:
    1. Scope globale (global scope): o Una variabile globale è dichiarata al di fuori di qualsiasi funzione o blocco di codice e può essere utilizzata in qualunque parte del programma, sia all'interno delle funzioni che al di fuori. o La sua vita dura per l'intero ciclo di esecuzione del programma. o Pro: può essere comoda quando serve condividere dati tra diverse parti del programma. o Contro: può portare a errori difficili da tracciare, in quanto le variabili globali possono essere sovrascritte accidentalmente in diverse parti del codice.
    2. Scope locale (local scope): o Una variabile locale è dichiarata all'interno di una funzione o un blocco di codice, come un ciclo for, e può essere utilizzata solo all'interno di quel contesto. o La vita di una variabile locale inizia quando viene dichiarata e termina quando l'esecuzione esce dalla funzione o dal blocco in cui è stata dichiarata. o Pro: aiuta a evitare conflitti di nome e rende il codice più sicuro, poiché la variabile è isolata. o Contro: non è accessibile da altre parti del programma, quindi la condivisione di dati deve essere fatta tramite il ritorno di valori o parametri passati a funzioni.
    3. Scope di blocco (block scope): o In alcuni linguaggi (come Java, C++, JavaScript,C#), le variabili dichiarate all'interno di un blocco {} (come nei cicli o negli if) hanno uno scope limitato a quel blocco. 19 6 Funzioni e Procedure Una funzione è un blocco di codice che esegue un compito specifico e restituisce un valore come risultato della sua esecuzione. Le funzioni prendono degli input sotto forma di parametri (o argomenti), eseguono una serie di operazioni su di essi e restituiscono un output. 6.1 Caratteristiche principali delle funzioni:
    4. Input: Una funzione può accettare uno o più parametri come input.
    5. Output: Restituisce sempre un valore (anche null o void in alcuni linguaggi se non ha un risultato significativo).
    6. Modularità: Le funzioni sono utili per evitare la ripetizione di codice, permettendo di riutilizzare blocchi di codice comuni.
    7. Chiamata: Quando una funzione viene chiamata, il controllo del programma viene trasferito alla funzione, e una volta terminata l'esecuzione, il controllo ritorna al punto di chiamata.
    8. Purezza: Alcune funzioni possono essere considerate "pure" se non hanno effetti collaterali, cioè non modificano lo stato esterno (come variabili globali o dati esterni) e restituiscono sempre lo stesso output per lo stesso input. (Esempio in programmazione funzionale). int Somma(int a, int b) { return a + b; } int Main() { int risultato = Somma(3, 4); Console.WriteLine(risultato); // Output: 7 return 0; } 6.2 Procedure Una procedura è simile a una funzione, ma non restituisce un valore. Esegue un insieme di istruzioni o operazioni, ma il suo scopo principale è eseguire un'azione piuttosto che calcolare e restituire un risultato. Le procedure possono comunque accettare parametri e modificare il loro stato o quello dell'ambiente circostante.
    • Caratteristiche principali delle procedure: o Input: Come le funzioni, una procedura può accettare uno o più parametri. o Output: Non restituisce un valore esplicito (sebbene possa modificare lo stato di variabili o dati). o Modularità: Le procedure, come le funzioni, consentono di scomporre il codice in blocchi logici e riutilizzabili. o Chiamata: Come nelle funzioni, il controllo del programma passa alla procedura quando viene chiamata e ritorna alla fine della procedura. using System; class Program { static void Saluta(string nome) { Console.WriteLine("Ciao, " + nome + "!"); // Non restituisce nulla, ma esegue un'azione } static void Main() { Saluta("Marco"); // Output: Ciao, Marco! } } 20 Introduzione alla 00P La Programmazione Orientata agli Oggetti (OOP, Object-Oriented Programming) è un paradigma di programmazione che si basa sul concetto di "oggetti". Gli oggetti sono istanze di classi e possono contenere dati e metodi che operano su quei dati. Questo approccio è molto utile per progettare e gestire software complesso, favorendo la modularità e la riusabilità del codice.
    • Classi e Oggetti o Classe: Una classe è una "blueprint" o un modello che definisce un tipo di oggetto. Contiene attributi (dati) e metodi (funzioni) che determinano il comportamento degli oggetti creati da essa. o Oggetto: Un oggetto è un'istanza di una classe. Rappresenta un'entità concreta che ha uno stato (valori degli attributi) e un comportamento (metodi). 6.2.1 In sintesi:  Classe: è una struttura che definisce proprietà e metodi.  Oggetto: è un'istanza concreta di una classe.  Istanza: è un termine che indica un oggetto specifico creato da una classe. Un modo per visualizzare tutto questo è pensare a una classe come una "stampo" per creare oggetti: lo stampo definisce la forma generale (classe), e ogni oggetto prodotto dallo stampo è un'istanza unica (oggetto/istanza). In programmazione orientata agli oggetti (OOP), i concetti di classe, oggetto e istanza sono fondamentali. Vediamo come sono collegati e quali sono le loro differenze: I linguaggi che consentono di attuare i principi della programmazione a oggetti hanno tre fattori in comune: l'incapsulazione, il polimorfismo e l'ereditarietà. 6.2.2 Concetti Fondamentali dell'OOP
    • Incapsulamento L'incapsulamento è il principio di nascondere i dettagli interni di un oggetto e di esporre solo un'interfaccia pubblica. In pratica, significa che i dati di un oggetto sono accessibili solo tramite metodi pubblici definiti nella classe.
    • Ereditarietà L'ereditarietà consente di definire una nuova classe basata su una classe esistente. La nuova classe (chiamata classe derivata o sottoclasse) eredita attributi e metodi dalla classe esistente (chiamata classe base o superclasse), e può estendere o modificare il comportamento ereditato.
    1. Polimorfismo Il polimorfismo permette a metodi con lo stesso nome di comportarsi in modo diverso a seconda del contesto. Ad esempio, un metodo può essere sovrascritto in una sottoclasse per fornire una nuova implementazione, mentre in una classe base può avere una diversa. 21 7 Astrazione L'astrazione implica la rappresentazione di concetti complessi attraverso modelli semplificati. In OOP, le classi forniscono un'astrazione dei dati e dei comportamenti, permettendo di lavorare con oggetti e metodi senza preoccuparsi dei dettagli implementativi. 7.1 Costruttori Il costruttore di una classe è un metodo che permette di stabilire come un oggetto deve essere creato, cioè di controllare la sua inizializzazione. E’ obbligatorio che il costruttore si chiami esattamente come la classe, e che non venga specificato alcun tipo di ritorno, neanche void, in quanto quello che restituisce un costruttore è proprio l’oggetto che esso deve costruire. Se per sbaglio o per distrazione scriviamo un costruttore con un tipo di ritorno void o un altro tipo, il compilatore segnalerà comunque l’errore, in quanto esso verrà visto come un membro qualsiasi della classe, ed un membro non può naturalmente avere lo stesso nome della classe che lo contiene. Un costruttore, come un qualsiasi altro metodo, può avere o meno dei parametri. Supponiamo di volere costruire un oggetto della classe Veicolo specificando il numero di ruote, allora scriveremo un costruttore che ha come parametro un intero: public class Veicolo { int nRuote; string targa; float velocita; //costruttore public Veicolo(int ruote) { nRuote=ruote; } Non è necessario comunque implementare un costruttore, in quanto, in tal caso, viene di default fornito quello senza parametri. Notate che se implementate almeno un costruttore nelle vostre classi, allora quello di default non sarà più disponibile, cioè se la classe Veicolo è stata definita come sopra non è più possibile istanziare un oggetto come abbiamo fatto finora con Veicolo auto=new Veicolo(); //non esiste il costruttore ma è necessario usare quello che abbiamo definito sopra e che prende in ingresso un intero: Veicolo auto=new Veicolo(4); Per ogni classe possiamo implementare tutti i costruttori che vogliamo, naturalmente ognuno con un numero o con un tipo differente di parametri, così come abbiamo visto parlando dell’overloading degli altri metodi della classe. 7.2 Overloading dei metodi In C# una classe può avere più metodi con lo stesso nome, ma con numero e/o tipo di parametri. Ad esempio il metodo per ottenere il quadrato di un numero intero: public int Quadrato(int a){ return aa; } non può accettare un parametro a virgola mobile, ad esempio non è possibile invocare il metodo nella maniera seguente: double d=Quadrato(2.1); 22 Sia perché il metodo quadrato non accetta come parametro un double, ed inoltre il tipo di ritorno è ancora int, mentre noi tentiamo di assegnare alla variabile d che è double. Magari si potrebbe risolvere questo semplice caso con una conversione di tipo, ma il concetto che vogliamo esporre è che è possibile implementare diversi metodi Quadrato(ognuno dei quali accetta diversi tipi di parametro, ad esempio: public double Quadrato(double d) { return dd; } in tale maniera il compilatore sa che se invochiamo il metodo passando un parametro int deve utilizzare la versione Quadrato(int a), mentre se invochiamo il metodo Quadrato con un parametro double deve utilizzare la seconda versione. Questa tecnica viene chiamata overloading, cioè sovraccarico dei metodi, ed è una tecnica fondamentale nella programmazione ad oggetti, ed è dunque assolutamente necessario imparare a maneggiarla. 7.3 Modificatori di accesso L’accesso alle informazioni è regolato per mezzo dei modificatori di accesso. Per default i membri di una classe sono private, ma è consigliabile comunque specificare il tipo di accesso in modo esplicito per evitare fraintendimenti. Una dichiarazione di classe in generale può essere dichiarata con uno dei seguenti modificatori: Modificatore d’accesso Descrizione Per le Classi internal La classe è accessibile solo a classi dello stesso assembly, questo è il livello di visibilità predefinito. public Classe visibile anche al di fuori dell ‘assembly contentente la classe stessa. Per gli attributi e metodi public I membri pubblici solo visibili a qualunque altra classe e relativi membri. protected I membri protected sono accessibili oltre che dalla classe stessa, anche dalle classi derivate da essa. private I membri privati sono visibili solo all’interno della classe stessa. internal I membri internal sono visibili all’interno dell’assembly in cui è definita la classe. protected internal I mebri protected internal sono accessibili alle classi La maggior parte delle classi viene dichiarata come public, quindi visibile anche in assembly diversi da quello di appartenenza. Se si omette il modificatore di accesso, verrà sottinteso che esso sia internal, dunque che la classe è visibile solo all’interno del suo stesso assembly. Notate che non è possibile in genere utilizzare il modificatore private ad una classe o ad elementi che sono contenuti direttamente in un namespace, perchè non avrebbe senso in quanto in questa maniera la classe non sarebbe utilizzabile da nessuno, mentre è possibile definire una classe privata se innestata in un’altra come vedremo fra qualche riga. Il modificatore private applicato ad un membro di una classe, ad esempio ad un suo campo, indica che tale membro è visibile ed utilizzabile solo da istanze della classe stessa, mentre il suo accesso sarà impedito ad oggetti di classi diverse. Il modificatore public invece permette l’accesso da oggetti di qualunque altra classe. e scrivessimo una classe come la seguente 23 7.4 L’incapsulazione In un linguaggio a oggetti, il codice e i dati possono essere raggruppati in modo da creare una sorta di "scatola nera". Quando il codice e i dati vengono raggruppati in questo modo, si crea un oggetto. In altre parole, un oggetto è un "dispositivo" che supporta l'incapsulazione. L'incapsulazione è il meccanismo che riunisce insieme il codice e i dati da esso manipolati e che mette entrambi al sicuro da interferenze o errati utilizzi. All'interno di un oggetto, il codice, i dati o entrambi possono essere definiti privati per tale oggetto oppure pubblici. public class Persc { private string nome; private string cognome; } public void Salute() { Console.WiteLine("Ciao, sono {nome} {cognome}"); } Il codice o i dati privati sono noti e accessibili solo da parte degli elementi dell'oggetto stesso. Questo significa che il codice e i dati privati non risultano accessibili da parte di elementi del programma che si trovano all'esterno dell'oggetto. Se il codice o i dati sono pubblici, risulteranno accessibili anche da altre parti del programma che non sono definite all'interno dell'oggetto. Generalmente, le parti pubbliche di un oggetto sono utilizzate per fornire un'interfaccia controllata agli elementi privati dell'oggetto stesso. Un oggetto è, in tutto e per tutto, una variabile di un tipo definito dall'utente. Può sembrare strano pensare a un oggetto, che contiene codice e dati, come a una variabile; tuttavia, nella programmazione a oggetti avviene proprio questo. Ogni volta che si definisce un nuovo tipo di oggetto, si crea implicitamente un nuovo tipo di dato. Ogni specifica istanza di questo tipo è una variabile composta. 7.5 EREDITARIETA’ Il concetto di ereditarietà è molto importante nella programmazione ad oggetti. Esso ci consente di creare nuove classi che riutilizzano, estendono e modificano il comportamento già definito in altre classi. La classe i cui membri sono ereditati è chiamata classe di base, mentre la classe che eredita dalla classe base viene chiamata classe derivata. // Classe base public class Animale { public string Nome { get; set;} public Animale(string nome) //Costruttore public Animale(string nome) { Nome = nome;} public virtual void Parla() { Console.WriteLine("L'animale fa un suono.");} 24 Concettualmente, una classe derivata è una specializzazione della classe base. Ad esempio, nel grafico qui sopra riportato, possiamo notare di come la classe base Animale venga estesa da due classi derivate: la classe Uccello e la classe Mammifero. Per quanto sia i mammiferi che gli uccelli siano degli animali, le loro diversità li fanno specializzare in rami differenti. In C#, per derivare da una classe base, usiamo una notazione molto sintetica, ovvero: public class Cane: Animale{} // Classe derivata public class Cane : Animale { public Cane(string nome) : base(nome) { // Sovrascrittura del metodo public override void Parla() { Console.WriteLine("Il cane abbaia."); } } Qui sotto un altro esempio con la classe di base Person, rappresentante il concetto di persona, che, in questo caso, viene derivata da due classi: Student e Teacher. Quest’ultime ereditano le info presenti in Person e ci aggiungono ulteriori properties, ridefiniscono alcuni metodi e ne aggiungono di nuovi, specifici dell’implementazione. Quest’ultimo esempio introduce un concetto molto importante e fondamentale, ovvero la sovrascrittura dei metodi. Nella fattispecie, possiamo vedere come nella classe Person ci siano // Definizione della classe Person public class Person { // Propriete private private string name; private int age; // Costruttore public Person(string name, int age) { This.name = name; this.age = age; } // Propriete pubblica per ottenere e impostare it nome public string Name { get { return name; } set { name = value; } } // Propriete pubblica per ottenere e impostare Age public int Age { get { return age; } set { age = value; } } // Metodo pubblico public virtual void Introduce() { Console.WriteLine("Hello, my name is {name} and I am {age} years old");}} Classe derivata Classe Person: Proprietà Private: name e age sono dati privati che non possono essere accessibili direttamente dall'esterno della classe. Questo è un esempio di incapsulamento. Costruttore: Inizializza le proprietà name e age quando viene creato un oggetto Person. Proprietà Pubbliche: Name e Age sono utilizzate per accedere e modificare le proprietà private. Metodo Pubblico: Introduce è un metodo che stampa una presentazione dell'oggetto Person. È dichiarato come virtual, il che significa che può essere sovrascritto nelle classi derivate (es. Student). Ereditarietà: Student eredita da Person, il che significa che Student ha accesso ai membri della classe Person. 25 Proprietà Aggiuntiva: StudentId è una proprietà aggiuntiva specifica per la classe Student. Costruttore: Il costruttore di Student chiama il costruttore della classe base (Person) per inizializzare le proprietà ereditate. Metodo Sovrascritto: Introduce è sovrascritto per includere informazioni specifiche sullo studente, utilizzando la parola chiave override. Chiama anche il metodo della classe base con base.Introduce() // Classe derivata Student the estende Person public class Student : Person { // Propriety aggiuntiva public string Studentld { get; set; // Costruttore della classe derivata public Student(string name, int age, string studentId) : base(name, age) { Studentld = studentld; } // Metodo sovrascritto public override void Introduce() { base.Introduce(); // Chiamata al metodo della classe base Console.WriteLine("I am a student with ID: {Studentld}.");}} Affinché un metodo possa essere sovrascritto da una classe, è necessario dichiararlo nella classe di base con la keyword virtual. Così facendo, la sottoclasse in questione avrà la possibilità di ridefinirlo a seconda delle necessità. Se invece, al posto di virtual, una classe di base dichiara un metodo o una proprietà come abstract, allora quel metodo o quella proprietà dovranno per forza essere sovrascritti dalla classe derivata. L'ereditarietà è lo strumento che permette di costruire nuove classi utilizzando quelle già realizzate. 8 Le interfacce In C#, un'interfaccia (interface) è un contratto che definisce un insieme di metodi, proprietà, eventi o indicizzatori che una classe o una struttura deve implementare. Tuttavia, l'interfaccia non contiene l'implementazione di questi membri; definisce solo la loro firma, lasciando il compito di fornire l'implementazione a classi o strutture che la implementano. 8.1.1 Caratteristiche principali di un'interfaccia in C#:  Contratto: Un'interfaccia specifica ciò che una classe deve fare, ma non come farlo.  Membri: Può dichiarare metodi, proprietà, eventi e indicizzatori, ma senza implementazioni.  Implementazione obbligatoria: Una classe che implementa un'interfaccia deve fornire l'implementazione di tutti i membri definiti nell'interfaccia.  Ereditarietà multipla: In C#, una classe può implementare più interfacce, anche se non può ereditare da più classi. 8.1.2 Sintassi di un'interfaccia La dichiarazione di un'interfaccia usa la parola chiave interface. Ecco un esempio di base: public interface IVeicolo{ void Avvia(); void Ferma(); int Velocità { get; set; } } In questo esempio, l'interfaccia IVeicolo definisce due metodi (Avvia() e Ferma()) e una proprietà (Velocità), ma non fornisce l'implementazione. 26 8.1.3 Implementazione di un'interfaccia Una classe può implementare un'interfaccia fornendo l'implementazione dei membri definiti nell'interfaccia. La sintassi prevede l'uso della parola chiave : , seguita dal nome dell'interfaccia. public class Auto : IVeicolo{ public int Velocità { get; set; } public void Avvia() { Console.WriteLine("L'auto è stata avviata."); } public void Ferma() { Console.WriteLine("L'auto è stata fermata."); } } In questo esempio, la classe Auto implementa l'interfaccia IVeicolo. Fornisce l'implementazione dei metodi Avvia() e Ferma() e della proprietà Velocità. public interface IVeicolo { void Avvia(); void Ferma(); int Velocità { get; set; } } public class Auto : IVeicolo { public int Velocità { get; set; } public void Avvia() { Console.WriteLine("L'auto è stata avviata."); } public void Ferma() { Console.WriteLine("L'auto è stata fermata."); } } public class Moto : IVeicolo { public int Velocità { get; set; } public void Avvia() { Console.WriteLine("La moto è stata avviata."); } public void Ferma() { Console.WriteLine("La moto è stata fermata."); } } class Program { static void Main(string[] args) { IVeicolo veicolo1 = new Auto(); IVeicolo veicolo2 = new Moto(); veicolo1.Avvia(); veicolo2.Avvia(); veicolo1.Ferma(); veicolo2.Ferma(); } } 27 8.1.4 Ereditarietà multipla Una classe può implementare più di un'interfaccia. Ecco un esempio di una classe che implementa due interfacce: public interface IVolante { void Vola(); } public interface IVeicolo { void Avvia(); void Ferma(); } public class Aereo : IVolante, IVeicolo { public void Vola() { Console.WriteLine("L'aereo sta volando."); } public void Avvia() { Console.WriteLine("L'aereo è stato avviato."); } public void Ferma() { Console.WriteLine("L'aereo è stato fermato."); } } 8.1.5 Interfacce predefinite in C# C# fornisce alcune interfacce predefinite che sono molto utili, ad esempio:  IDisposable: Viene utilizzata per rilasciare le risorse non gestite. Il metodo principale è Dispose().  IComparable: Viene utilizzata per definire un metodo di confronto per ordinare oggetti.  IEnumerable: Viene utilizzata per fornire una funzionalità di enumerazione su una raccolta. 8.1.6 Differenze tra interfacce e classi astratte Sia le interfacce che le classi astratte definiscono un contratto per altre classi, ma ci sono alcune differenze:  Interfacce: Non possono avere implementazioni, ma solo la dichiarazione dei membri (a partire da C# 8.0, possono avere implementazioni predefinite per i metodi tramite metodi predefiniti).  Classi astratte: Possono avere sia membri astratti (senza implementazione) che membri concreti (con implementazione). 8.1.7 Conclusione Le interfacce sono un potente strumento in C# per promuovere la flessibilità e il riuso del codice. Consentono a diverse classi di implementare lo stesso insieme di funzionalità, indipendentemente dalla loro posizione nella gerarchia di ereditarietà, e sono ampiamente utilizzate nella programmazione orientata agli oggetti per favorire il principio dell'incapsulamento e l'uso di polimorfismo. 9 Overloading degli operatori In C#, l'overloading degli operatori (sovraccarico degli operatori) permette di definire o ridefinire il comportamento degli operatori predefiniti (come +, -, , /, ==, etc.) quando vengono applicati a oggetti di una classe o di una struttura. Questo rende il codice più intuitivo e leggibile, specialmente quando si lavora con tipi di dati personalizzati, come la classe dei numeri complessi che abbiamo visto prima. 28 9.1 Come funziona l'overloading degli operatori In C#, puoi sovraccaricare quasi tutti gli operatori, tranne alcuni (ad esempio, =, . e ?:). Per fare ciò, devi definire un metodo statico all'interno della tua classe o struttura, utilizzando la parola chiave operator seguita dall'operatore da sovraccaricare. Ogni operatore sovraccaricato deve restituire un valore e accettare almeno uno o due parametri (uno per gli operatori unari e due per quelli binari). // Sovraccarico dell'operatore + (somma di matrici) public static Matrice operator +(Matrice m1, Matrice m2) public static Matrice operator -(Matrice m1, Matrice m2) 9.2 Indicizzatore In C#, un indicizzatore (o indexer) è una caratteristica delle classi, strutture o interfacce che consente di accedere agli oggetti utilizzando la stessa sintassi di accesso agli array. In sostanza, permette di "indicizzare" un oggetto in base ad alcuni parametri, come se fosse un array, senza definire esplicitamente dei metodi get o set. Nel contesto delle matrici, un indicizzatore come this[int i, int j] permette di accedere agli elementi di una matrice utilizzando due indici, esattamente come si farebbe con un array bidimensionale. È una sintassi comoda per leggere o modificare gli elementi della matrice. 9.2.1 Sintassi dell'indicizzatore Un indicizzatore viene definito come un metodo di proprietà che utilizza la parola chiave this, seguita da parametri tra parentesi quadre. Ecco la struttura base di un indicizzatore: public T this[int i, int j] { get { / logica per restituire l'elemento alla posizione (i, j) / } set { / logica per impostare l'elemento alla posizione (i, j) / } } Esempio C# // Array che rappresenta la classe Matrice private double[,] elementi; // Indicizzatore per accedere agli elementi della matrice. public double this[int i, int j] { get { return elementi[i, j]; } set { elementi[i, j] = value; } } 10 File e directory Il namespace System.IO fornisce due coppie fondamentali di classi per la gestione di file e directory, in particolare per i primi abbiamo a disposizione le classi File e FileInfo, mentre per le directory le corrispondenti Directory e DirectoryInfo. La classe File contiene solo dei metodi statici, utili per la creazione, lo spostamento, la copia, l’eliminazione, l’apertura di file o per ottenere generiche informazioni su di essi, come il tempo di creazione di un file o i suoi atrributi. La tabella seguente riassume i principali metodi della classe File. Metodo Descrizione Open Apre un file esistente e restituisce un oggetto FileStream. Create Crea un file con nome e percorso specificati Delete Elimina il file specificato Copy Copia un file esistente in un’altra posizione 29 Move Sposta un file esistente in un’altra posizione Exists Verifica se un determinato file esiste OpenRead Apre un file esistente in lettura OpenWrite Apre un file esistente in scrittura CreateText Crea un file di testo con nome e percorso specificati OpenText Apre un file di testo in lettura AppendText Apre un file di testo per appendere del testo a quello esistente. Tali metodi hanno diversi overload, quindi è possibile utilizzarli in diversi modi, di cui vedremo i principali con qualche esempio, rinviando per ora i metodi che restituiscono un oggetto Stream.. Le seguenti righe mostrano come creare un file, copiarlo, spostarlo, ed eliminarlo: File.Create(@"c:\temp\prova.txt"); File.Copy(@"c:\temp\prova.txt","c:\temp\prova2.txt"); File.Move(@"c:\temp\prova.txt","c:\temp\prova3.txt"); File.Delete(@"c:\temp\prova.txt"); È bene prestare attenzione alle possibili eccezioni che possono essere generate da tali metodi. Ad esempio quando si tenta di eliminare un file inesistente o attualmente in uso da un altro processo sarà generata un’eccezione IOException: try{ File.Delete(@"c:\temp\prova.txt"); } catch(IOException ioe) { //gestione dell’eccezione } Prima di eliminare il file sarebbe opportuno anche verificare che esso esista, con il metodo Exists: if(!File.Exists(txtOrig.Text)) File.Delete(txtOrig.Text); Analogamente alla classe File, la classe Directory fornisce i metodi per manipolare una directory ed ottenere informazioni su di essa. La tabella seguente mostra i metodi principali della classe Directory: Metodo Descrizione CreateDirectory Crea una directory con nome e percorso specificati. Delete Elimina lsa directory specificata. Exists Copia una directory esistente in un’altra posizione. Move Sposta una directory esistente in un’altra posizione. GetFileSystemEntries Restituisce i file e le directory contenuti nella directory specificata GetFiles, GetDirectories Restituiscono i nomi dei file o delle sottodirectory di una directory specificata. GetDirectoryRoot Restituisce la radice del percorso specificato GetCurrentDirectory Restituisce la directory di lavoro corrente dell’applicazione. GetLogicalDrives Restituisce i drive logici presenti nel sistema. GetParent Restituisce la directory madre del percorso specificato AppendText Apre un file di testo per appendere del testo a quello esistente 30 Sia la classe File che la classe Directory permettono di ottenere e impostare i tempi di creazione o di accesso ad un dato elemento: creazione=File.GetCreationTime(@"c:\temp\pippo.txt").ToString(); File.SetLastWriteTime(@"c:\temp\pippo.txt",new DateTime(2000,8,2); string path=@"c:\temp\nuova cartella"; Directory.Create(path); Directory.SetLastAccessTime(path,new DateTime(1981,11,25)); Le due classi FileInfo e DirectoryInfo, come detto, forniscono anche metodi che permettono di ottenere altre informazioni sui file, come gli attributi, la data di creazione, la data di lettura e di modifica. A differenza delle classi File e Directory, le classi FileInfo e DirectoryInfo possono essere istanziate. Il metodo statico per creare una directory: Directory.CreateDirectory(@"c:\temp"); 10.1 Leggere e scrivere file Nell’esempio seguente, vengono creati un oggetto StreamReader (adatto alla lettura di un file testo) e un oggetto StreamWriter (adatto alla scrittura di un file testo).Il file che viene letto è “c:\temp\input.txt” e il file che viene scritto è ‘c:\temp\output.txt’. Quest’ultimo contiene il numero di byte di ogni riga del file di input. StreamReader fileRead = File.OpenText(@"c:\temp\input.txt"); StreamWriter fileWrite = File.CreateText(@"c:\temp\output.txt"); string buffer; while ((buffer = fileRead.ReadLine()) != null) fileWrite.WriteLine(buffer.Length); fileRead.Close(); fileWrite.Close(); Alternativa: using (StreamReader fileRead = File.OpenText(@"c:\temp\input.txt")) { using (StreamWriter fileWrite = File.CreateText(@"c:\temp\output.txt")) { string buffer; while ((buffer = fileRead.ReadLine()) != null) fileWrite.WriteLine(buffer.Length); } } 31 10.2 Lista dei file di una directory Per ottenere la lista dei file appartenenti ad una directory, utilizzare il codice seguente. Le classi utilizzate appartengono al namespace "System.IO.DirecoryInfo". Il metodo "GetFiles()", consente anche il filtraggio dei file. Nell'esempio seguente, tutti i file con estensione ".txt" sono inseriti in una lista. string path = @"C:\Temp"; DirectoryInfo dInfo = new DirectoryInfo(path); FileInfo[] files = dInfo.GetFiles("*.txt"); foreach (FileInfo file in files) { lstFiles.Items.Add(file.Name); } Determinare la directory corrente string path = Directory.GetCurrentDirectory(); Console.WriteLine("The current directory is {0}", path); Cambiare directory corrente string dir = @"C:\test"; try { //Set the current directory. Directory.SetCurrentDirectory(dir); } catch (DirectoryNotFoundException e) { Console.WriteLine("The specified directory does not exist. {0}", e); } 11 Espressioni Lambda In C#, le espressioni lambda possono essere utilizzate insieme a Func, Action e Predicate. Ecco un approfondimento su questi concetti e come usarli insieme. Le espressioni lambda sono funzioni anonime che possono essere utilizzate per creare metodi inline. La sintassi è : (parametri) => espressione 11.1 Func Func è un delegato predefinito che rappresenta un metodo che restituisce un valore. Può avere fino a 16 parametri. Il tipo di valore restituito e indicato come ultimo valore della lista di parametri. Func<int, int, int> somma = (x, y) => x + y; int risultato = somma(5, 10); // risultato sarà 15 Console.WriteLine("Somma:risultato");11.2ActionActioneˋundelegatocherappresentaunmetodochenonrestituisceunvalore(void).Puoˋaverefinoa16parametri.//DefinireunActionperstampareduenumeriAction<int,int>stampaSomma=(x,y)=>Console.WriteLine("Somma: {risultato}"); 11.2 Action Action è un delegato che rappresenta un metodo che non restituisce un valore (void). Può avere fino a 16 parametri. // Definire un Action per stampare due numeri Action<int, int> stampaSomma = (x, y) => Console.WriteLine("La somma di {x} e {y} è: {x
    • y}"); // Utilizzare l'Action stampaSomma(5, 10); // Stampa "La somma di 5 e 10 è: 15" 32 11.3 Predicate Predicate è un delegato predefinito utilizzato per definire metodi che restituiscono un valore booleano. Viene spesso utilizzato per filtrare dati. // Definire un Predicate per verificare se un numero è pari Predicate isEven = x => x % 2 == 0; Console.WriteLine(isEven(4)); // Stampa "True" Console.WriteLine(isEven(5)); // Stampa "False" class Program { static void Main() { // Func per sommare due numeri Func<int, int, int> somma = (x, y) => x + y; // Action per stampare il risultato Action stampaRisultato = risultato => Console.WriteLine($"Il risultato è: {risultato}"); // Predicate per verificare se il risultato è pari Predicate isEven = x => x % 2 == 0; // Calcolare e stampare il risultato int risultatoSomma = somma(10, 20); stampaRisultato(risultatoSomma); // Stampa "Il risultato è: 30" // Verificare se il risultato è pari if (isEven(risultatoSomma)) Console.WriteLine("Il risultato è un numero pari."); else Console.WriteLine("Il risultato è un numero dispari."); } } 11.3.1 Vantaggi di Lambda, Func, Action e Predicate
    • Sintassi Concisa: Le espressioni lambda offrono un modo breve per scrivere metodi.
    • Flessibilità: Puoi passare metodi come argomenti, il che rende il codice più modulare.
    • Filtraggio Efficiente: Predicate è utile per filtrare e trovare elementi in collezioni. fammi uno schema dettagliato, ora sto facendo questo: using System;

    class Program { static void Main(string[] args) { string input; string[] numeri; int numero; int pari = 0;

        // Richiesta all'utente di inserire una stringa di numeri
        while (true) // Loop infinito fino a quando non si ottiene un input valido
        {
            Console.WriteLine("Inserisci una serie di numeri separati da spazi:");
            input = Console.ReadLine();
    
            // Verifica se l'input non è vuoto
            if (!string.IsNullOrWhiteSpace(input))
            {
                numeri = input.Split(' '); // Split della stringa in un array di stringhe
    
                // Variabile per tenere traccia della validità degli input
                bool valido = true;
    
                // Controlla ogni numero nell'array
                foreach (string str in numeri)
                {
                    if (!int.TryParse(str, out numero)) // Usa TryParse per la conversione
                    {
                        Console.WriteLine($"'{str}' non è un numero valido. Riprova.");
                        valido = false; // Segnala che ci sono stati errori
                        break; // Esce dal foreach se viene trovata un'input non valido
                    }
    
                    // Se il numero è valido, verifica se è pari
                    if (numero % 2 == 0)
                    {
                        pari++; // Incrementa il contatore dei numeri pari
                    }
                }
    
                // Se tutti gli input sono validi, esci dal ciclo
                if (valido)
                {
                    break;
                }
            }
            else
            {
                Console.WriteLine("L'input non può essere vuoto. Riprova.");
            }
        }
    
        // Stampa il numero totale di numeri pari trovati
        Console.WriteLine("Numero totale di numeri pari: " + pari);
    }
    

    } fammi degli schemi per continuare a studiare il mio argomento

  2. Assistant

    Certamente! Creare schemi dettagliati può aiutarti a visualizzare e comprendere meglio i concetti che stai studiando. Di seguito, ti propongo una serie di schemi e diagrammi che coprono i principali argomenti trattati nel tuo corso di informatica su C#. Inoltre, includo un diagramma di flusso per il programma che stai sviluppando.


    1. Panoramica dei Concetti Principali

    1.1 Programmazione Procedurale vs. Programmazione Orientata agli Oggetti (OOP)

    CaratteristicaProgrammazione ProceduraleProgrammazione Orientata agli Oggetti (OOP)
    StrutturaSequenza di istruzioniClassi e oggetti
    ModularitàFunzioniMetodi all'interno delle classi
    Abilità di RiusoBasso, gestione manuale dei datiAlto, ereditarietà e polimorfismo
    IncapsulamentoLimitatoElevato, nasconde i dettagli interni degli oggetti
    Concetti ChiaveFunzioni, procedure, strutture di controlloClassi, oggetti, ereditarietà, polimorfismo, incapsulamento

    2. Strutture di Controllo

    2.1 Diagrammi di Flusso

    2.1.1 Struttura If-Else

                    +-----------+
                    | Condizione|
                    +-----+-----+
                          |
                 +--------+--------+
                 |                 |
             Vero (True)        Falso (False)
                 |                 |
        Esegui Blocco A      Esegui Blocco B
    

    2.1.2 Ciclo While

       +-----------------------+
       | Inizio                |
       +----------+------------+
                  |
                  v
        +-----------------+
        | Verifica Condizione |
        +---------+-------+
                  |
            +-----+-----+
            |           |
          Vero        Falso
            |            |
            v            |
       Esegui Blocco     |
            |            |
            +------------+
                  |
                  v
       +-----------------------+
       | Fine                  |
       +-----------------------+
    

    2.1.3 Ciclo For

       +-----------------------+
       | Inizio                |
       +----------+------------+
                  |
                  v
         Inizializzazione
                  |
                  v
         +-----------------+
         | Verifica Condizione |
         +---------+-------+
                  |
            +-----+-----+
            |           |
          Vero        Falso
            |            |
            v            |
       Esegui Blocco     |
            |            |
        Incremento       |
            |            |
            +------------+
                  |
                  v
       +-----------------------+
       | Fine                  |
       +-----------------------+
    

    2.2 Diagramma di Flusso del Tuo Programma C#

    [image: Diagramma di Flusso - Conta Numeri Pari] open

    Nota: Per visualizzare il diagramma di flusso, puoi creare un diagramma simile utilizzando strumenti come Microsoft Visio, Lucidchart o anche disegnandolo a mano.


    3. Programma Esempio: Conta Numeri Pari

    3.1 Struttura del Programma

    using System;
    
    class Program
    {
        static void Main(string[] args)
        {
            string input;
            string[] numeri;
            int numero;
            int pari = 0;
    
            // Richiesta all'utente di inserire una stringa di numeri
            while (true)
            {
                Console.WriteLine("Inserisci una serie di numeri separati da spazi:");
                input = Console.ReadLine();
    
                if (!string.IsNullOrWhiteSpace(input))
                {
                    numeri = input.Split(' ');
                    bool valido = true;
    
                    foreach (string str in numeri)
                    {
                        if (!int.TryParse(str, out numero))
                        {
                            Console.WriteLine($"'{str}' non è un numero valido. Riprova.");
                            valido = false;
                            break;
                        }
    
                        if (numero % 2 == 0)
                        {
                            pari++;
                        }
                    }
    
                    if (valido)
                    {
                        break;
                    }
                }
                else
                {
                    Console.WriteLine("L'input non può essere vuoto. Riprova.");
                }
            }
    
            Console.WriteLine("Numero totale di numeri pari: " + pari);
        }
    }
    

    3.2 Diagramma delle Classi

    [image: Diagramma delle Classi - Programma Conta Numeri Pari] open

    Nota: Questo programma è relativamente semplice e utilizza solo la classe Program con il metodo Main.

    3.3 Spiegazione Passo-Passo

    1. Dichiarazione delle Variabili:

      • input: Stringa per memorizzare l'input dell'utente.
      • numeri: Array di stringhe ottenuto suddividendo l'input.
      • numero: Variabile temporanea per la conversione.
      • pari: Contatore per i numeri pari.
    2. Loop Infinito (while (true)):

      • Richiede all'utente di inserire una serie di numeri separati da spazi.
      • Controlla se l'input non è vuoto.
      • Divide l'input in singoli numeri.
      • Utilizza foreach per iterare su ciascun numero:
        • Tenta di convertire ogni stringa in un intero con int.TryParse.
        • Se la conversione fallisce, avvisa l'utente e richiede un nuovo input.
        • Se il numero è pari (numero % 2 == 0), incrementa il contatore pari.
      • Se tutti i numeri sono validi, esce dal loop.
    3. Output:

      • Stampa il conteggio totale dei numeri pari inseriti.

    4. Concetti Avanzati

    4.1 Funzioni e Delegati

    4.1.1 Definizione di Funzione

    Una funzione è un blocco di codice che esegue un compito specifico e può restituire un valore.

    int Somma(int a, int b)
    {
        return a + b;
    }
    

    4.1.2 Delegati, Func, Action e Predicate

    TipoDescrizioneEsempio
    DelegatoRappresenta un riferimento a un metodo con una firma specifica.public delegate int Operazione(int a, int b);
    FuncDelegato predefinito che restituisce un valore.Func<int, int, int> somma = (x, y) => x + y;
    ActionDelegato predefinito che non restituisce un valore.Action<int> stampa = x => Console.WriteLine(x);
    PredicateDelegato predefinito che restituisce un bool.Predicate<int> isEven = x => x % 2 == 0;

    5. Programmazione Orientata agli Oggetti (OOP)

    5.1 Concetti Fondamentali

    ConcettoDescrizioneEsempio
    ClasseBlueprint per creare oggetti, definisce proprietà e metodi.public class Auto { ... }
    OggettoIstanza di una classe.Auto miaAuto = new Auto();
    EreditarietàUna classe può ereditare da un'altra classe, assumendo le sue proprietà e metodi.public class Corsa : Auto { ... }
    PolimorfismoCapacità di trattare oggetti di classi diverse in modo uniforme attraverso un'interfaccia comune.Utilizzo di metodi virtuali e override.
    IncapsulamentoNascondere i dettagli interni di un oggetto, esponendo solo ciò che è necessario.Proprietà private con getter/setter pubblici.

    5.2 Diagramma delle Relazioni tra Classi

    [image: Diagramma OOP - Ereditarietà e Interfacce] open

    Nota: Utilizza classi come Animale, Cane, Gatto, e interfacce come IVeicolo per rappresentare le relazioni.


    6. Gestione dei File

    6.1 Operazioni di Base con la Classe File

    MetodoDescrizioneEsempio
    File.Create(path)Crea un nuovo file.File.Create(@"c:\temp\prova.txt");
    File.Copy(source, dest)Copia un file da source a dest.File.Copy(@"c:\temp\prova.txt", @"c:\temp\prova2.txt");
    File.Move(source, dest)Sposta un file da source a dest.File.Move(@"c:\temp\prova.txt", @"c:\temp\prova3.txt");
    File.Delete(path)Elimina il file specificato.File.Delete(@"c:\temp\prova.txt");

    6.2 Esempio di Lettura e Scrittura dei File

    using System;
    using System.IO;
    
    class Program
    {
        static void Main()
        {
            // Creazione degli oggetti StreamReader e StreamWriter
            using (StreamReader fileRead = File.OpenText(@"c:\temp\input.txt"))
            using (StreamWriter fileWrite = File.CreateText(@"c:\temp\output.txt"))
            {
                string buffer;
                while ((buffer = fileRead.ReadLine()) != null)
                {
                    fileWrite.WriteLine(buffer.Length);
                }
            }
    
            Console.WriteLine("Processing completed.");
        }
    }
    

    Spiegazione:

    • StreamReader legge il contenuto del file input.txt riga per riga.
    • StreamWriter scrive la lunghezza di ogni riga nel file output.txt.
    • Utilizzo della struttura using per garantire che i file vengano chiusi automaticamente.

    7. Espressioni Lambda e Delegati

    7.1 Introduzione alle Espressioni Lambda

    Le espressioni lambda sono funzioni anonime utilizzate per creare metodi inline in modo conciso.

    Sintassi Base:

    (parametri) => espressione
    

    Esempio:

    Func<int, int, int> somma = (x, y) => x + y;
    int risultato = somma(5, 10); // Risultato: 15
    

    7.2 Utilizzo di Func, Action e Predicate

    TipoDescrizioneEsempio
    FuncDelegato che restituisce un valore.Func<int, int, int> somma = (x, y) => x + y;
    ActionDelegato che non restituisce un valore.Action<string> stampa = s => Console.WriteLine(s);
    PredicateDelegato che restituisce un bool, usato per filtrare dati.Predicate<int> isEven = x => x % 2 == 0;

    7.3 Esempio Completo con Func, Action e Predicate

    using System;
    
    class Program
    {
        static void Main()
        {
            // Func per sommare due numeri
            Func<int, int, int> somma = (x, y) => x + y;
    
            // Action per stampare il risultato
            Action<int> stampaRisultato = risultato => Console.WriteLine($"Il risultato è: {risultato}");
    
            // Predicate per verificare se il risultato è pari
            Predicate<int> isEven = x => x % 2 == 0;
    
            // Calcolare e stampare il risultato
            int risultatoSomma = somma(10, 20);
            stampaRisultato(risultatoSomma); // Output: Il risultato è: 30
    
            // Verificare se il risultato è pari
            if (isEven(risultatoSomma))
            {
                Console.WriteLine("Il risultato è un numero pari.");
            }
            else
            {
                Console.WriteLine("Il risultato è un numero dispari.");
            }
        }
    }
    

    Output:

    Il risultato è: 30
    Il risultato è un numero pari.
    

    8. Suggerimenti per Continuare lo Studio

    8.1 Esercizi Pratici

    1. Espandi il Programma Conta Numeri Pari:

      • Conta anche i numeri dispari.
      • Calcola la somma totale dei numeri inseriti.
      • Trova il numero massimo e minimo.
    2. Implementare una Classe Veicolo:

      • Crea una classe Veicolo con proprietà come Marca, Modello, Velocità.
      • Implementa metodi come Avvia(), Ferma().
      • Crea sottoclassi come Auto, Moto che estendono Veicolo.
    3. Gestione dei File:

      • Crea un programma che legge un file di testo, filtra le linee che contengono una parola specifica e le scrive in un altro file.

    8.2 Risorse Utili


    9. Schema Riassuntivo del Programma Conta Numeri Pari

    +-------------------------------------------------------+
    |               Programma Conta Numeri Pari             |
    +-------------------------------------------------------+
    | Variabili:                                            |
    | - input (string)                                       |
    | - numeri (string[])                                    |
    | - numero (int)                                         |
    | - pari (int) = 0                                       |
    +-------------------------------------------------------+
    | Inizio Main                                           |
    +-------------------------------------------------------+
    | Loop Infinito (while true)                            |
    |   |                                                    |
    |   v                                                    |
    | Richiedi input all'utente                             |
    |   |                                                    |
    |   v                                                    |
    | Controlla se l'input non è vuoto                      |
    |   |                                                    |
    |   +-- Se vero:                                         |
    |   |    Split dell'input in array 'numeri'              |
    |   |    Imposta 'valido' = true                         |
    |   |                                                    |
    |   |    Itera su ogni stringa in 'numeri'               |
    |   |      |                                              |
    |   |      v                                              |
    |   |   Tenta di convertire in int (TryParse)            |
    |   |      |                                              |
    |   |      +-- Se fallisce:                               |
    |   |      |    Stampa messaggio di errore                 |
    |   |      |    Imposta 'valido' = false                   |
    |   |      |    Esci dal foreach                           |
    |   |      +-- Se riesce:                                  |
    |   |           Controlla se il numero è pari             |
    |   |           Incrementa 'pari' se vero                 |
    |   |                                                    |
    |   |    Se 'valido' == true:                             |
    |   |       Esci dal loop                                 |
    |   |                                                    |
    |   +-- Se falso:                                        |
    |        Stampa messaggio di input vuoto                |
    +-------------------------------------------------------+
    | Stampa il numero totale di numeri pari                |
    +-------------------------------------------------------+
    | Fine Programma                                         |
    +-------------------------------------------------------+
    

    10. Conclusione

    Seguendo questi schemi e diagrammi, puoi acquisire una comprensione più chiara e strutturata dei concetti fondamentali della programmazione in C#. È importante combinare la teoria con la pratica: prova a scrivere codice, sperimenta con diverse strutture e applica i concetti appresi in esercizi concreti. Se hai ulteriori domande o hai bisogno di approfondimenti su specifici argomenti, non esitare a chiedere!

    Buono studio!