Tesi Case Roberto

788 views

Published on

Published in: Technology, Business
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
788
On SlideShare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
9
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Tesi Case Roberto

  1. 1. UNIVERSITÀ DEGLI STUDI DI TRIESTE ____________________________________________ Facoltà di Ingegneria CORSO DI LAUREA TRIENNALE IN INGEGNERIA INFORMATICA PROVA FINALE PROGETTAZIONE E SVILUPPO DI UN’APPLICAZIONE PER IL DIMENSIONAMENTO DI IMPIANTI DI DEPURAZIONE DI TERRENI Laureando: Relatore: Roberto Case Prof. Maurizio Fermeglia ____________________________________________ ANNO ACCADEMICO 2007/2008
  2. 2. Indice generale 1. Introduzione............................................................... p. 1 2. Analisi e progettazione................................................ p. 3 2.1. Analisi................................................................. p. 3 2.1.1. Definizione dei requisiti................................. p. 4 2.1.2. Strumento attuale......................................... p. 5 2.1.3. Prototipo....................................................... p. 5 2.2. Progettazione....................................................... p. 7 2.2.1. Progettazione dataset.................................... p. 8 2.2.2. Progettazione software.................................. p. 10 2.2.2.1. Persistenza dei dati............................ p. 10 2.2.2.2. Precaricamento valori di default......... p. 12 2.2.2.3. Processo di calcolo............................. p. 13 2.2.3. Tecnologie..................................................... p. 13 3. Realizzazione.............................................................. p. 15 3.1. Interfaccia........................................................ p. 15 3.1.1. Schede.................................................. p. 16 3.1.2. Controlli................................................ p. 17 3.1.3. Menù.................................................... p. 18 3.1.4. Altri particolari...................................... p. 20 3.1.5. Esempio d’uso....................................... p. 20 3.2. Implementazione.............................................. p. 22 3.2.1. Dati...................................................... p. 22 3.2.2. Struttura dataset.................................. p. 24 3.2.3. Diagrammi di flusso.............................. p. 27 i
  3. 3. 3.2.4. Blocchi funzionali................................. p. 28 4. Conclusioni................................................................ p. 30 5. Appendice A................................................................ p. 32 6. Appendice B............................................................... p. 36 7. Bibliografia................................................................. p. 48 ii
  4. 4. 1. Introduzione Gesteco, società del Gruppo Luci, offre servizi relativi alla bonifica in situ di aree inquinate su tutto il territorio nazionale ed estero; a riguardo ha progettato e realizzato grandi interventi di bonifica per committenti sia pubblici che privati. Nell’ambito della progettazione di nuovi impianti di depurazione di terreni ha trovato spazio lo sviluppo di questa tesi. A questo scopo, l’azienda ha la necessità di dimensionare l’attività di bonifica, tenendo conto di molti parametri fisici e chimici, ed inoltre di preventivare economicamente l’opera. Per questo motivo può risultare necessario avere degli strumenti per memorizzare ed elaborare questi parametri. Lo scopo di questo lavoro è quello di realizzare uno di questi strumenti, sotto forma di applicazione software, in grado di sostituire i fogli di calcolo attualmente utilizzati. L’esigenza 1
  5. 5. principale è quella di automatizzare il meccanismo di dimensionamento di un nuovo impianto, passando dai suddetti fogli di calcolo ad un’unica e più comoda applicazione. I punti principali trattati in questo lavoro sono: • Studio della tecnologia • Analisi dei requisiti e progettazione dell’applicazione • Realizzazione dell’applicazione: interfaccia e implementazione Nei seguenti capitoli saranno esposti in dettaglio questi punti, partendo dall’analisi dei requisiti del committente e dallo studio di ciò che esisteva prima di questa tesi, per poi passare alla progettazione della nuova applicazione, accennando anche alle tecnologie utilizzate. Nel secondo capitolo saranno esposte le due parti principali della realizzazione dell’applicazione: l’interfaccia, ovvero come si utilizza il software, e l’implementazione, ovvero cosa sta alla base del suo funzionamento. 2
  6. 6. 2. Analisi e progettazione 2.1. Analisi L’attività di analisi sta alla base della realizzazione di un software e precede la progettazione. Il suo compito è quello di definire bisogni e obiettivi del committente, dimensionati anche alle possibilità di realizzazione del fornitore. La prima parte di questa attività si compone di interviste con il committente e con i futuri utenti del software; queste non sono state parte del lavoro di tesi. Quello che invece è stato fatto è l’analisi dei requisiti, nonché un breve “studio” dello strumento utilizzato al momento delle interviste. 3
  7. 7. 2.1.1. Definizione dei requisiti Ciò che è stato richiesto è un’applicazione in grado di fornire un output, definito come sequenza di processi elementari, sulla base di vari input, quali dati fisici e chimici dei terreni da trattare. Stabiliti quindi i suddetti processi, l’applicazione deve permettere un’analisi del rendimento e dei costi di utilizzo dell’impianto dimensionato, partendo da valori riguardanti il nuovo cantiere e i processi stessi. La somma di questi requisiti fa si che il dimensionamento di un nuovo impianto avvenga in maniera automatizzata e quindi più veloce. In questa fase, un diagramma UML dei casi d’uso può aiutare a comprendere i requisiti funzionali della futura applicazione. Nel presente caso, quello di più alto livello è illustrato di seguito. GestEco Creazione nuovo progetto «uses» «uses» Modifica progetto esistente «uses» Utente Analisi rendimento e costi 4
  8. 8. 2.1.2. Strumento attuale Nella prima fase di raccolta dei dati sono stati resi disponibili dal committente due file rappresentanti l’attuale metodologia di dimensionamento dei nuovi impianti. Questi file, costituiti da fogli di calcolo, vengono utilizzati per la raccolta dei dati, per la loro elaborazione e per la consultazione di tabelle. È parso subito evidente che l’acquisizione e l’elaborazione non avrebbero subito particolari miglioramenti, mentre la parte che avrebbe tratto i maggiori vantaggi sarebbe stata la consultazione delle tabelle divenendo completamente automatizzata. Questa prima analisi ha permesso quindi di avere un’idea generale sull’aspetto funzionale dell’applicazione e sui tipi di dati da trattare e ha inoltre suggerito un possibile sviluppo dell’interfaccia. È stato a questo punto evidente che il nuovo software avrebbe dovuto permettere l’acquisizione di una certa quantità di dati e l’elaborazione di questi tramite alcuni algoritmi di calcolo. 2.1.3. Prototipo In seguito alla prima analisi si è pensato di realizzare un prototipo minimale da esporre al committente in un successivo colloquio, al fine di mostrare e verificare le funzionalità da implementare nel prodotto finale, senza rispettare le specifiche non funzionali. 5
  9. 9. Particolare attenzione è stata posta all’interfaccia, dato che l’adozione di una applicazione in sostituzione dei fogli di calcolo, poteva comportare qualche difficoltà di accettazione da parte del committente. Il prototipo è stato accettato e quindi la progettazione e la realizzazione sono state successivamente sviluppate a partire da questo. 6
  10. 10. 2.2. Progettazione Nello sviluppo di un software la progettazione è la fase permette, basandosi sui requisiti appena analizzati, di identificare le specifiche che dovranno essere rispettate dall’applicazione. A differenza dei requisiti, le specifiche sono nozioni utili al fornitore per la realizzazione e non devono essere condivise con il committente. Le specifiche permettono di avere un’immagine del progetto ad un livello intermedio tra i bisogni del committente e la codifica dei moduli. Ciò significa che alla fine di questa attività si avrà 7
  11. 11. un’idea di come sarà strutturato il software, ma non di come sarà implementato internamente ogni suo modulo. 2.2.1. Progettazione dataset L’acquisizione di valori riguardanti un nuovo dimensionamento e la necessità di salvare e caricare tali dati per eventuali modifiche ha portato alla decisione di inserire nel software un dataset, il cui compito è quello di organizzare i dati per l’applicazione. Un dataset rappresenta un set di dati che include le tabelle in cui essi sono contenuti, ordinati e vincolati e gestisce le relazioni tra le tabelle stesse. La progettazione del dataset necessita di tre passaggi: progettazione concettuale, logica e fisica. In questa parte della tesi si è presa in considerazione solo la progettazione concettuale, utile per ragionare sulla realtà d’interesse indipendentemente dagli aspetti realizzativi. La prima operazione da fare è analizzare le parti che dovranno comporre il dataset, quindi capire quali sono le entità e quali le relazioni che devono farne parte. Per questo motivo sono state realizzate le due tabelle seguenti. Dizionario dei dati (entità) Entità Descrizione Attributi Identificatore Terreno Identifica Nome Progetto, Nome Progetto una Cliente, porzione di Quantità 8
  12. 12. territorio Materiale Ton, con i relativiQuantità dati fisici e Materiale Mc, chimici Tipo Materiale, Codice CER, Tipo Inquinante, Destinazione Materiale, Localita, Durata, Ore Giorno, capacità Giornaliera, Capacità Oraria, Dati chimici, Dati fisici Processo Identifica un Nome Processo, Nome Processo passaggio Bilancio di nel materia, Costi, trattamento Macchina di un terreno Dizionario dei dati (relationship) Relazione Descrizione Componenti Trattamento È un insieme di Terreno, Processo processi per la lavorazione di un terreno Sulla base di queste tabelle è stato possibile realizzare lo schema E-R del dataset. 9
  13. 13. 2.2.2. Progettazione software La formulazione delle specifiche prevede che, oltre ai dati di ingresso e di uscita che dovrà avere l’applicazione, vengano indicate anche le varie funzioni da implementare per rispondere ai requisiti del committente. Tali funzionalità saranno descritte nei seguenti paragrafi, mentre per la definizione di input e output si rimanda al capitolo successivo. 2.2.2.1. Persistenza dei dati su file Una volta definito un progetto, è stato necessario prevedere la possibilità di salvarlo su disco, così da consentirne un’elaborazione o una consultazione futura. Avendo temporaneamente memorizzato l’insieme dei dati in un dataset, il modo migliore per implementare il loro salvataggio è parso quello di creare dei file con estensione .xml. Questa si è rivelata una buona scelta anche dal punto di vista del caricamento di un progetto, in quanto questo tipo di file 10
  14. 14. permette di popolare il dataset automaticamente grazie ai tag presenti all’interno del file stesso. Di seguito viene riportato un esempio di file .xml: La progettazione di queste funzionalità ha reso necessaria la creazione di alcuni diagrammi di flusso atti a chiarire la gestione di un progetto aperto al momento della creazione o del caricamento di un altro progetto o della chiusura dell’applicazione. Le prime due situazioni nascono dal fatto che non possono essere caricati dal software più progetti contemporaneamente. Quindi, nella situazione in cui un progetto sia aperto e si voglia, ad esempio, crearne uno nuovo, si deve tener presente che il progetto aperto può esser stato modificato e quindi richiedere all’utente se salvare i cambiamenti o meno. È necessario porsi lo 11
  15. 15. stesso quesito nel caso in cui un progetto aperto abbia subito delle modifiche e l’utente decida di chiudere l’applicazione. 2.2.2.2. Precaricamento valori di default Come già detto in precedenza, le informazioni di un progetto vengono caricate in un dataset. Una parte di tale dataset si compone di tabelle di lookup contenenti valori indipendenti dall’esistenza del singolo progetto. Il contenuto di queste tabelle dev’essere caricato all’atto della creazione di un nuovo progetto. Oltre al contenuto delle tabelle appena citate, un progetto ha, come anticipato, dei dati caratterizzanti da salvare in altre tabelle del dataset. La creazione di un nuovo progetto porta al popolamento di queste tabelle, alcune delle quali con una sigola riga, altre con più righe e con valori copiati dalle tabelle di lookup per mantenere dei riferimenti al momento in cui un progetto viene creato. Mentre le tabelle di lookup possono variare indipendentemente dal progetto, le altre sono correlate ad esso e quindi si è presentata la necessità di “congelare” alcuni valori presenti al momento esatto della creazione del progetto. 2.2.2.3. Processo di calcolo 12
  16. 16. Le ultime funzionalità dell’applicazione riguardano l’elaborazione dei dati ricevuti in ingresso. Tramite letture del dataset per prelevare dei valori e formulazioni matematiche che rispecchino i vari processi, si è passati alla progettazione delle funzioni di calcolo del rendimento e dei costi di utilizzo dell’impianto dimensionato. Per quanto riguarda il rendimento, è stato necessario definire un modulo contenente le procedure cablate per i diversi processi, in modo da determinare, sulla base dei dati del progetto, le caratteristiche di lavorazione dei processi stessi. L’analisi dei costi di utilizzo è stata impostata su dati forniti dal committente e su alcuni dati derivanti dal modulo di calcolo del rendimento. 2.2.2.4. Tecnologie Già all’inizio di questa tesi era ben chiaro quali avrebbero dovuto essere gli strumenti utilizzati per la realizzazione del progetto. Questo fatto si può definire come una specifica non funzionale, ovvero un vincolo posto al progetto. Come piattaforma si è deciso di utilizzare Microsoft .NET Framework, affiancato quindi dal linguaggio di programmazione C#, dalla tecnologia ADO.NET e dall’ambiente di sviluppo Visual Studio. 13
  17. 17. L’insieme di questi strumenti ha permesso di creare la struttura dei dati e l’accesso ad essi da parte dell’applicazione. Ha consentito inoltre lo sviluppo dell’interfaccia e dell’implementazione del codice che sta alla base dell’applicazione. 14
  18. 18. 3. Realizzazione 3.1. Interfaccia L’interfaccia è la parte del software a diretto contatto con l’utente e deve rendere l’utilizzo dell’applicazione più intuitivo e semplice possibile. Il primo giudizio che l’utente dà riguardo al sistema è in realtà ciò che egli percepisce dall’aspetto dell’interfaccia, non certo da ciò che sta dietro ed essa. 15
  19. 19. 3.1.1. Schede Dalla definizione dei dati da acquisire si è deciso di creare l’interfaccia sulla falsa riga delle tabelle presenti nei file .xls. Per fare ciò sono stati “convertiti” i singoli fogli del file “operazioni.xls” in tabPages ognuna delle quali doveva rappresentare un sottoinsieme preciso dei dati acquisiti o ancora da acquisire. Le schede realizzate sono le seguenti: • Dati progetto • Dati cantiere • Analisi chimiche tal quale • Analisi chimiche di base • Analisi chimiche secondo granulometria Si può notare come, rispetto al file preso in considerazione, non sia stata introdotta una scheda che potremmo chiamare “Granulometria”. Questo perché non è sembrato utile avere le classi granulometriche sia nell’ultima scheda, sebbene lì siano divise in base alla frazione, sia in una tabella che le avesse contenute tutte. 16
  20. 20. 3.1.2. Controlli All’interno delle schede sono stati posti tre tipi di controlli: • textBox • comboBox • dataGridView Il controllo textBox è il più semplice e permette di inserire una stringa grazie alla sua proprietà Text. Questo lo rende utile per campi semplici in cui c’è la necessità di inserire testi sia numerici che in lettere. Paragonato al precedente, il controllo comboBox presenta una funzionalità in più, ovvero la possibilità di definire più valori e di scegliere quello che si desidera. Tale controllo si adatta bene a campi nei quali siano definiti dei valori standard tra i quali selezionare quello di interesse. Focalizzando l’attenzione sulla comboBox presente nella scheda “Analisi chimiche secondo granulometria”, si può notare come 17
  21. 21. questa sia utilizzata non per acquisire dei valori, ma bensì per selezionare i dati da visualizzare nelle dataGridView sottostanti. Le dataGridView offrono l’opportunità di replicare strutture tabellari con la possibilità di modificarne o meno il contenuto. Queste sono state utilizzate per visualizzare parti di tabelle del dataset, consentendo così all’utente una migliore interazione con le stesse. In particolare, nella scheda “Analisi chimiche secondo granulometria” si è inserita un’ulteriore caratteristica sulla prima tabella. Questa tabella riproduce i dati della frazione granulometrica selezionata e li indica con un colore associato a tale frazione. Questo comportamento, realizzato agendo sulla proprietà “RowsDefaultCellStyle.BackColor” della dataGridView attraverso l’evento “SelectedIndexChanged” della comboBox, è stato aggiunto prendendo spunto da uno dei file in possesso. La possibilità di visualizzare i dati contenuti nel dataset è dovuta al fatto che tutti i controlli sono stati associati ad un bindingSource. Questo strumento si interpone tra il controllo e l’origine dati da associarvi, consentendo il collegamento tra quest’ultima e una o più proprietà del controllo stesso. 3.1.3. Menù Le funzionalità dell’applicazione sono state rese disponibili attraverso dei menù. Questi si rifanno ai menù delle applicazioni 18
  22. 22. più utilizzate dagli utenti, così da aumentare l’intuitività e l’usabilità dell’interfaccia. I menù presenti, con le relative espansioni, sono due: • File o New o Open o Save o Save As ... o Exit • Progetto o Selezione processi Il menù “File” permette le consuete azioni di creazione, caricamento e salvataggio di un nuovo progetto. Il menù “Progetto” permette invece di avere accesso alle funzioni di analisi del rendimento e dei costi di utilizzo del progetto corrente. Il possibile utilizzo del software da parte di utenti esperti ha imposto l’utilizzo degli “shortcut”, ovvero delle “scorciatoie” da tastiera alternative alla selezione dei menù tramite il mouse. 19
  23. 23. 3.1.4. Altri Particolari Nella parte superiore della form, attraverso la proprietà Text, è stato inserito il nome dell’applicazione, che in questo caso coincide con quello del committente. Nel caso in cui venga caricato un progetto esistente, il contenuto della proprietà viene modificato visualizzando anche il nome del progetto. Infine, nella zona inferiore, è stata inserita una barra di stato. In caso di apertura e salvataggio di un progetto, questa barra indica lo stato dell’applicazione, mentre, nel caso in cui un progetto sia già caricato, essa indica il percorso del file .xml contenente i dati. 3.1.5. Esempio d’uso In questo paragrafo viene descritto un esempio di funzionamento dell’applicazione. 20
  24. 24. Avviata l’applicazione, tutti i campi appaiono vuoti. A questo punto si supponga di dover creare un nuovo progetto. L’operazione da eseguire è avviabile attraverso il menù “File” alla voce “New”. Ora l’applicazione si presenta con dei valori pari a zero di default. È questo il momento di inserire i dati relativi al nuovo progetto. Pensando di non voler perdere i dati inseriti si decida di salvare il progetto sul disco. Entrando quindi nel menù “File” è possibile scegliere tra le voci “Save” e “Save As ...”. La prima chiederà il nome da assegnare al file e la posizione nella quale salvarlo solo nel caso in cui il progetto non sia già stato salvato, quindi anche nel caso in esame, altrimenti questa voce salva le modifiche del file nella posizione in cui questo si trovava all’istante del suo caricamento. La voce “Save As ...” chiede in ogni caso dove salvare il progetto. Nel caso qui trattato la selezione di una qualsiasi delle due voci porta all’apertura di una finestra di dialogo dove inserire il nome del futuro file e scegliere la posizione nel disco in cui salvarlo. A questo punto il file può essere caricato in ogni momento l’utente lo desideri. Questo viene fatto attraverso la voce “Open” del menù “File”. Selezionando tale voce viene visualizzata un’altra finestra di dialogo dove poter scegliere il file da caricare. La presenza di un progetto aperto, e quindi dei suoi dati, fa in modo che si possano sfruttare le funzioni di analisi del rendimento e dei costi di utilizzo tramite il menù “Progetto”. 3.2. Implementazione 21
  25. 25. Questa parte del lavoro di tesi ha avuto il compito di definire come le varie parti del software dovevano essere realizzate al loro interno. Si è trattato quindi di progettare logicamente e fisicamente il dataset e di implementare le procedure dei blocchi funzionali. 3.2.1. Dati In primo luogo si è deciso di definire un insieme di informazioni composto dai dati di ingresso e da quelli di uscita come un progetto gestibile tramite l’applicazione. A fronte di ciò sono stati individuati i seguenti input: • Dati di progetto o Cliente o Quantità di materiale (mc) o Quantità di materiale (ton) o Tipologia di materiale o Codice CER o Tipologia di inquinanti o Destinazione del materiale trattato • Dati di cantiere o Località del cantiere o Durata del cantiere o Ore di lavoro giorno o Capacità giornaliera di trattamento 22
  26. 26. o Capacità oraria di trattamento • Analisi chimiche tal quale o Su vari composti • Analisi chimiche di base o Aspetto o Colore o Odore o PH (soluzione acquosa) o Sostanza secca 105° C o Sostanza secca 600° C o Volatili o Conducibilità (soluzione acquosa) o Peso specifico • Caratteristiche granulometriche o Su varie classi granulometriche • Analisi chimiche secondo granulometria o Su varie frazioni e vari composti • Dati relativi a ogni processo o “Prestazioni” o Costi utilizzo macchine ed i seguenti output: Processi necessari • o Materiale in ingresso o Materiale in uscita • Costi 23
  27. 27. o Costo mese o Costo giorno o Costo tonnellata o Costo KW • Consumo giorno energia elettrica Altri dati vanno poi ad affiancare quelli già elencati, ma non tutti costituiscono vere e proprie informazioni sul progetto. Questi dati possono variare nel tempo e vengono copiati all’interno di quelli del progetto per mantenere i valori precisi del momento in cui il progetto stesso è stato creato. 3.2.2. Struttura dataset Con riferimento ai dati sopra definiti e allo schema E-R creato nel capitolo precedente si è passati a strutturare logicamente il dataset. Sarebbe stato necessario creare delle tabelle per analizzare le attività sulle varie parti del futuro dataset, ma la mancanza di alcuni dati aziendali non hanno permesso questo passaggio. Di conseguenza, la definizione dello schema logico tramite il partizionamento delle entità iniziali in varie tabelle è stata fatta solo approssimativamente. Questa fase ha sostanzialmente diviso il futuro dataset in tre parti: 24
  28. 28. • Tabelle del progetto • Tabelle di lookup • Tabelle di analisi del rendimento e dei costi di utilizzo Le prime derivano dall’entità concettuale “Terreno” e sono state strutturate in modo da contenere i dati strettamente legati al progetto. Esse contengono quindi quei valori invariabili nel tempo, che nascono e muoiono con il progetto stesso. 25
  29. 29. Le tabelle di lookup hanno lo scopo di contenere dei dati indipendenti dal progetto. Il loro utilizzo è soprattutto di supporto all’inizializzazione delle tabelle dei dati riguardanti il progetto. Nel corso del tempo i valori di queste tabelle possono subire delle variazioni, che non devono però intaccare i progetti già esistenti. Non si è reso necessario un vero e proprio studio concettuale di questa parte, ma solo la definizione dei loro contenuti: • tblComposto o ID o Descrizione o Min o Max • tblClasse o ID o Descrizione o IDFrazione o Scala o IntervalloDimensionale • tblFrazione o ID o Descrizione Le ultime tabelle derivano dalla restante entità, ovvero “Processo”, e contengono i dati riguardanti appunto i vari processi di trattamento: alcuni per l’aspetto del rendimento e 26
  30. 30. quindi delle quantità di materia lavorate, altri per l’aspetto dei costi di utilizzo correlati quindi ai macchinari utilizzati per il processo stesso. 3.2.3. Diagrammi di flusso I diagrammi di flusso visti al capitolo precedente sono stati a questo punto implementati con procedure in C#. Essi rappresentano tre situazioni in cui si ha un progetto aperto e si vuole intraprendere una delle seguenti operazioni: creazione di un nuovo progetto, caricamento di un progetto esistente o chiusura dell’applicazione. La sequenza di test, presente in ugual modo nei tre casi, inizia controllando se esiste o meno un progetto aperto. Nel caso esso 27
  31. 31. non esista, questo test fallisce e si procede direttamente con l’operazione desiderata. Nel caso in cui il progetto sia aperto, si passa a testare se questo è stato modificato dal momento del suo caricamento, del salvataggio precedente o della creazione. Anche in quest’eventualità l’esito negativo del test fa si che si intraprenda direttamente l’operazione desiderata. A questo punto, se anche il secondo test ha dato esito positivo, si offre all’utente la possibilità di salvare o meno le modifiche, tramite finestra di dialogo se il progetto è appena stato creato o automaticamente se il progetto era già esistente. 3.2.4. Blocchi funzionali I blocchi funzionali progettati sono stati tre, riguardanti rispettivamente i file, il dataset e i dati. Ogni blocco è un insieme di procedure. Il primo contiene le procedure che stanno alla base dei tre diagrammi descritti al paragrafo precedente e quindi, al suo interno, si trovano quelle per gestire la creazione di un nuovo file e il suo caricamento. Nel secondo blocco sono presenti invece procedure relative al dataset, come il popolamento delle tabelle di lookup e la creazione di un nuovo progetto, ovvero della “riga pilota” e di tutte le righe relazionate ad essa. Infine nel terzo blocco sono state poste quelle procedure in grado di elaborare i dati di ingresso e di fornire i relativi output. Queste 28
  32. 32. consistono nella creazione della sequenza di processi necessari per il trattamento del terreno e nell’analisi del rendimento dell’impianto e dei costi di utilizzo. L’analisi necessita, oltre che dei dati di ingresso, di altri dati riguardanti le macchine utilizzate. 29
  33. 33. 4. Conclusioni L’obiettivo principale del presente lavoro era la progettazione e lo sviluppo dell’applicazione. La prima è stata svolta completamente, essendo ora definito tutto il progetto in ogni sua parte; per quanto riguarda lo sviluppo, invece, non tutto è stato realizzato, perché si attende ancora del materiale da parte del committente ed una sua verifica. L’esperienza di questa tesi è stata interessante per diversi aspetti, primo tra tutti l’essere a contatto, anche se in minima parte, con il mondo del lavoro. Un elaborato come questo dà la possibilità di capire quanto sia impegnativo realizzare un’applicazione reale per un committente. È stato inoltre utile apprezzare come la progettazione sia un processo iterativo e come possano presentarsi delle situazioni 30
  34. 34. nelle quali è necessario cambiare le proprie idee per l’aggiunta di materiale da parte di chi richiede il software. Alla fine di questa tesi non c’è stata piena soddisfazione per il solo fatto di non aver ancora visto consegnata l’applicazione. Infine, lo stato attuale dell’arte si compone dell’interfaccia e della gestione dei file complete, mentre presenta solo in parte le funzionalità sul rendimento e sui costi. Nel prossimo futuro sarà quindi necessario terminare la realizzazione per passare poi alla fase di test e al rilascio dell’applicazione. 31
  35. 35. 5. Appendice A Codice degli eventi legati alla form using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace GestEco { public partial class MainForm : Form { public MainForm() { InitializeComponent(); } private void menuExit_Click(object sender, EventArgs e) { this.Close(); 32
  36. 36. } private void menuNew_Click(object sender, EventArgs e) { progettoAperto(sender, e); nuovo(); this.statusLabel.Text = quot;Nuovo progettoquot;; } private void menuOpen_Click(object sender, EventArgs e) { progettoAperto(sender, e); string status = this.statusLabel.Text; this.statusLabel.Text = quot;Apertura progettoquot;; //finestre di apertura progetto OpenFileDialog dlg = new OpenFileDialog(); dlg.Title = quot;Apri progettoquot;; dlg.Filter = quot;Xml files (*.xml)|*.xml|quot; + quot;All files (*.*)|*.*quot;; dlg.RestoreDirectory = true; if (dlg.ShowDialog() == DialogResult.OK) carica(dlg.FileName); else this.statusLabel.Text = status; dlg.Dispose(); } private void menuSave_Click(object sender, EventArgs e) { string status = this.statusLabel.Text; this.statusLabel.Text = quot;Salvataggio progettoquot;; if (nomeFile == null) menuSaveAs_Click(sender, e); else salva(); this.statusLabel.Text = status; } private void menuSaveAs_Click(object sender, EventArgs e) { string status = this.statusLabel.Text; this.statusLabel.Text = quot;Salvataggio progettoquot;; 33
  37. 37. //finestre per scegliere la posizione di salvataggio SaveFileDialog dlg = new SaveFileDialog(); dlg.Title = quot;Salva progettoquot;; dlg.Filter = quot;Xml files (*.xml)|*.xml|quot; + quot;All files|*.*quot;; dlg.RestoreDirectory = true; if (dlg.ShowDialog() == DialogResult.OK) salva(dlg.FileName); else this.statusLabel.Text = status; dlg.Dispose(); } private void cmbSelFrazione_SelectedIndexChanged(object sender, EventArgs e) { //filtri per dataGrid della schedaAnalisiChimGran switch (cmbSelFrazione.SelectedIndex) { case 0: bsAnalisiChimicheGranulometria.Filter = quot;IDFrazione = 1quot;; bsGranulometria.Filter = quot;IDFrazione = 1quot;; dgGranulometria.RowsDefaultCellStyle.BackColor = Color.RoyalBlue; dgGranulometria.RowsDefaultCellStyle. SelectionBackColor = Color.RoyalBlue; break; case 1: bsAnalisiChimicheGranulometria.Filter = quot;IDFrazione = 2quot;; bsGranulometria.Filter = quot;IDFrazione = 2quot;; dgGranulometria.RowsDefaultCellStyle. BackColor = Color.LimeGreen; dgGranulometria.RowsDefaultCellStyle. SelectionBackColor = Color.LimeGreen; break; case 2: bsAnalisiChimicheGranulometria.Filter = quot;IDFrazione = 3quot;; bsGranulometria.Filter = quot;IDFrazione = 3quot;; dgGranulometria.RowsDefaultCellStyle. BackColor = Color.Orange; dgGranulometria.RowsDefaultCellStyle. SelectionBackColor = Color.Orange; 34
  38. 38. break; case 3: bsAnalisiChimicheGranulometria.Filter = quot;IDFrazione = 4quot;; bsGranulometria.Filter = quot;IDFrazione = 4quot;; dgGranulometria.RowsDefaultCellStyle. BackColor = Color.Yellow; dgGranulometria.RowsDefaultCellStyle. SelectionBackColor = Color.Yellow; break; } } private void MainForm_FormClosing(object sender, FormClosingEventArgs e) { progettoAperto(sender, e); } private void menuProcessi_Click(object sender, EventArgs e) { report(); } } } 35
  39. 39. 6. Appendice B Codice dei blocchi funzionali using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace GestEco { public partial class MainForm { //----------------------------------------- // VARIABILI RIGUARDANTI IL PROGETTO APERTO //----------------------------------------- public string nomeFile; private Int32 ID; 36
  40. 40. //----------------------------------------------------- // PROCEDURA PER LA POPOLAZIONE DELLE TABELLE DI LOOKUP //----------------------------------------------------- private void LookUp() { //righe tabella tblTipoMateriale dataSetGestEco1.tblTipoMateriale. AddtblTipoMaterialeRow(1, quot;sedimentiquot;); dataSetGestEco1.tblTipoMateriale. AddtblTipoMaterialeRow(2, quot;terreniquot;); //righe tabella tblTipoInquinante dataSetGestEco1.tblTipoInquinante. AddtblTipoInquinanteRow(1, quot;organiciquot;); dataSetGestEco1.tblTipoInquinante. AddtblTipoInquinanteRow(2, quot;inorganiciquot;); dataSetGestEco1.tblTipoInquinante. AddtblTipoInquinanteRow(3, quot;mistiquot;); dataSetGestEco1.tblTipoInquinante. AddtblTipoInquinanteRow(4, quot;RSAUquot;); //righe tabella tblDestinazioneMateriale dataSetGestEco1.tblDestinazioneMateriale. AddtblDestinazioneMaterialeRow(1, quot;recuperoquot;); dataSetGestEco1.tblDestinazioneMateriale. AddtblDestinazioneMaterialeRow(2, quot;discaricaquot;); //righe tabella tblComposto dataSetGestEco1.tblComposto.AddtblCompostoRow(1, quot;antimonioquot;, 10, 30); dataSetGestEco1.tblComposto.AddtblCompostoRow(2, quot;arsenicoquot;, 20, 50); dataSetGestEco1.tblComposto.AddtblCompostoRow(3, quot;berilioquot;, 2, 10); dataSetGestEco1.tblComposto.AddtblCompostoRow(4, quot;cadmioquot;, 2, 15); dataSetGestEco1.tblComposto.AddtblCompostoRow(5, quot;cobaltoquot;, 20, 250); dataSetGestEco1.tblComposto.AddtblCompostoRow(6, quot;cromo totalequot;, 150, 800); dataSetGestEco1.tblComposto.AddtblCompostoRow(7, quot;cromo VIquot;, 2, 15); dataSetGestEco1.tblComposto.AddtblCompostoRow(8, quot;mercurioquot;, 1, 5); dataSetGestEco1.tblComposto.AddtblCompostoRow(9, quot;nichelquot;, 120, 500); dataSetGestEco1.tblComposto.AddtblCompostoRow(10, quot;piomboquot;, 100, 1000); dataSetGestEco1.tblComposto.AddtblCompostoRow(11, 37
  41. 41. quot;ramequot;, 120, 600); dataSetGestEco1.tblComposto.AddtblCompostoRow(12, quot;selenioquot;, 3, 15); dataSetGestEco1.tblComposto.AddtblCompostoRow(13, quot;stagnoquot;, 1, 350); dataSetGestEco1.tblComposto.AddtblCompostoRow(14, quot;tallioquot;, 1, 10); dataSetGestEco1.tblComposto.AddtblCompostoRow(15, quot;vanadioquot;, 90, 250); dataSetGestEco1.tblComposto.AddtblCompostoRow(16, quot;zincoquot;, 150, 1500); dataSetGestEco1.tblComposto.AddtblCompostoRow(17, quot;cianuri (liberi)quot;, 1, 100); dataSetGestEco1.tblComposto.AddtblCompostoRow(18, quot;fluoruriquot;, 100, 2000); //righe tabella tblFrazione DataSetGestEco.tblFrazioneRow rigaFrazione1 = dataSetGestEco1.tblFrazione.AddtblFrazioneRow(1, quot;Classe1quot;, quot;RoyalBluequot;); DataSetGestEco.tblFrazioneRow rigaFrazione2 = dataSetGestEco1.tblFrazione.AddtblFrazioneRow(2, quot;Classe2quot;, quot;LimeGreenquot;); DataSetGestEco.tblFrazioneRow rigaFrazione3 = dataSetGestEco1.tblFrazione.AddtblFrazioneRow(3, quot;Classe3quot;, quot;Orangequot;); DataSetGestEco.tblFrazioneRow rigaFrazione4 = dataSetGestEco1.tblFrazione.AddtblFrazioneRow(4, quot;Classe4quot;, quot;Yellowquot;); //righe tabella tblClasse dataSetGestEco1.tblClasse.AddtblClasseRow(1, quot;blocchiquot;, rigaFrazione1, quot;< -8quot;, quot;> 256 mmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(2, quot;ciottoliquot;, rigaFrazione1, quot;-6 a -8quot;, quot;64 - 256 mmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(3, quot;ghiaia molto grossaquot;, rigaFrazione1, quot;-5 a -6quot;, quot;32 - 64 mmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(4, quot;ghiaia grossaquot;, rigaFrazione1, quot;-4 a -5quot;, quot;16 -32 mmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(5, quot;ghiaia mediaquot;, rigaFrazione1, quot;-3 a -4quot;, quot;8 - 16 mmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(6, quot;ghiaia finequot;, rigaFrazione2, quot;-2 a -3quot;, quot;4 - 8 mmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(7, quot;ghiaia molto finequot;, rigaFrazione2, quot;-1 a -2quot;, quot;2 - 4 mmquot;); 38
  42. 42. dataSetGestEco1.tblClasse.AddtblClasseRow(8, quot;sabbia molto grossaquot;, rigaFrazione2, quot;0 a -1quot;, quot;1 - 2 mmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(9, quot;sabbia grossaquot;, rigaFrazione3, quot;1 a 0quot;, quot;0,5 - 1 mmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(10, quot;sabbia mediaquot;, rigaFrazione3, quot;2 a 1quot;, quot;0,25 - 0,5 mmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(11, quot;sabbia finequot;, rigaFrazione3, quot;3 a 2quot;, quot;125 - 250 µmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(12, quot;sabbia molto finequot;, rigaFrazione4, quot;4 a 3quot;, quot;62,5 - 125 µquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(13, quot;silt (limo)quot;, rigaFrazione4, quot;8 a 4quot;, quot;3,9 - 62,5 µmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(14, quot;argillaquot;, rigaFrazione4, quot;> 8quot;, quot;< 3,9 µmquot;); dataSetGestEco1.tblClasse.AddtblClasseRow(15, quot;colloidequot;, rigaFrazione4, quot;> 10quot;, quot;< 1 µmquot;); //rghe tabella tblProcesso dataSetGestEco1.tblProcesso.AddtblProcessoRow(1, quot;Vagliatura grossolanaquot;, quot;L'operazione di vagliatura grossolana serve per eliminare i corpi grossolani fino ad un taglio di ghiaia media 16 mmquot;); dataSetGestEco1.tblProcesso.AddtblProcessoRow(2, quot;I Spappolamentoquot;, quot;L'operazione di spappolamento è funzione della tipologia di materiale in ingresso è assimilabile o comparabile ad un lavaggioquot;); dataSetGestEco1.tblProcesso.AddtblProcessoRow(3, quot;Vagliatura dopo spappolamentoquot;, quot;L'operazione di vagliatura dopo lo spappolameto permette di separe la ghiaia sabbia fino ad un taglio di ghiaia media 1- 2 mmquot;); dataSetGestEco1.tblProcesso.AddtblProcessoRow(4, quot;II Spappolamentoquot;, quot;quot;); dataSetGestEco1.tblProcesso.AddtblProcessoRow(5, quot;Classificazione sabbiequot;, quot;quot;); dataSetGestEco1.tblProcesso.AddtblProcessoRow(6, quot;Classificazione finiquot;, quot;quot;); dataSetGestEco1.tblProcesso.AddtblProcessoRow(7, quot;Ispessimentoquot;, quot;quot;); dataSetGestEco1.tblProcesso.AddtblProcessoRow(8, quot;Disidratazionequot;, quot;quot;); 39
  43. 43. //righe tabella tblFrazioneQuantita dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(1, rigaFrazione1, quot;quot;, 0, 0); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(2, rigaFrazione1, quot;quot;, 1, 15); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(3, rigaFrazione1, quot;quot;, 15, 30); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(4, rigaFrazione1, quot;quot;, 30, 100); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(5, rigaFrazione2, quot;quot;, 0, 15); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(6, rigaFrazione2, quot;quot;, 15, 30); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(7, rigaFrazione2, quot;quot;, 30, 100); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(8, rigaFrazione3, quot;quot;, 0, 15); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(9, rigaFrazione3, quot;quot;, 15, 30); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(10, rigaFrazione3, quot;quot;, 30, 100); //righe tabella tblProcessoInFrazioneQuantita foreach (DataSetGestEco.tblProcessoRow riga in dataSetGestEco1.tblProcesso) { foreach (DataSetGestEco.tblFrazioneQuantitaRow riga1 in dataSetGestEco1.tblFrazioneQuantita) { switch (riga1.IDFrazione) { case 1: if (riga.ID == 1 && riga1.Min == 0) break; else dataSetGestEco1. tblProcessoInFrazioneQuantita. AddtblProcessoInFrazioneQuantitaRow(riga, 40
  44. 44. riga1); break; case 2: if (riga.ID == 1) break; else dataSetGestEco1. tblProcessoInFrazioneQuantita. AddtblProcessoInFrazioneQuantitaRow( riga, riga1); break; case 3: if (riga.ID == 1 || riga.ID == 2 || riga.ID == 3) break; else dataSetGestEco1. tblProcessoInFrazioneQuantita. AddtblProcessoInFrazioneQuantitaRow(riga, riga1); break; } } } //righe tabella tblUM dataSetGestEco1.tblUM.AddtblUMRow(1, quot;mc/hquot;); dataSetGestEco1.tblUM.AddtblUMRow(2, quot;mc/gquot;); dataSetGestEco1.tblUM.AddtblUMRow(3, quot;ton/hquot;); dataSetGestEco1.tblUM.AddtblUMRow(4, quot;ton/gquot;); } //----------------------------------------------------------- // PROCEDURE PER LE CREAZIONE DELLE RIGHE RIGUARDANTI UN // NUOVO PROGETTO //----------------------------------------------------------- //riga nuovo progetto private void RigaProgetto() { DataSetGestEco.tblProgettoRow row = dataSetGestEco1.tblProgetto.AddtblProgettoRow(quot;quot;); row.Nome = quot;Progettoquot; + row.ID; ID = (Int32)row.ID; } //righe altre tabelle 41
  45. 45. private void RigheTabelle() { //riga tblDatiProgetto dataSetGestEco1.tblDatiProgetto. AddtblDatiProgettoRow(dataSetGestEco1. tblProgetto.FindByID(ID), quot;quot;, 0, 0, null, quot;quot;, null, null); //riga tblDatiCantiere dataSetGestEco1.tblDatiCantiere. AddtblDatiCantiereRow(dataSetGestEco1. tblProgetto.FindByID(ID), quot;quot;, 0, 0, 0, 0); //riga tblAnalisiChimicaTalQuale foreach (DataSetGestEco.tblCompostoRow riga in dataSetGestEco1.tblComposto) dataSetGestEco1.tblAnalisiChimicaTalQuale. AddtblAnalisiChimicaTalQualeRow(riga, dataSetGestEco1.tblProgetto.FindByID(ID), riga.Min, riga.Max, 0); //riga tblAnalisiChimicaGranulometria foreach (DataSetGestEco.tblFrazioneRow riga in dataSetGestEco1.tblFrazione) { foreach (DataSetGestEco.tblCompostoRow riga1 in dataSetGestEco1.tblComposto) dataSetGestEco1.tblAnalisiChimicaGranulometria. AddtblAnalisiChimicaGranulometriaRow( dataSetGestEco1.tblProgetto.FindByID(ID), riga, riga1, riga1.Min, riga1.Max, 0, 0); } //riga tblGranulometria foreach (DataSetGestEco.tblFrazioneRow riga1 in dataSetGestEco1.tblFrazione) { foreach (DataSetGestEco.tblClasseRow riga in dataSetGestEco1.tblClasse) { if (riga.IDFrazione == riga1.ID) dataSetGestEco1.tblGranulometria. AddtblGranulometriaRow(riga, dataSetGestEco1.tblProgetto.FindByID(ID), 0, riga.IntervalloDimensionale, riga.Scala, riga1); } } 42
  46. 46. //riga tblAnalisiChimicaBase dataSetGestEco1.tblAnalisiChimicaBase. AddtblAnalisiChimicaBaseRow(null, null, null, 0, 0, 0, 0, 0, 0, dataSetGestEco1.tblProgetto. FindByID(ID)); } //------------------------------------------------------- // PROCEDURE PER GESTIRE IL PROGETTO APERTO O PER CREARNE // UNO NUOVO //------------------------------------------------------- public void nuovo() { nomeFile = null; dataSetGestEco1.Clear(); LookUp(); RigaProgetto(); RigheTabelle(); } public void salva() { dataSetGestEco1.WriteXml(nomeFile); dataSetGestEco1.AcceptChanges(); } public void salva(string nomeFile) { dataSetGestEco1.WriteXml(nomeFile); dataSetGestEco1.AcceptChanges(); } public void carica(string nomeFile) { dataSetGestEco1.Clear(); dataSetGestEco1.ReadXml(nomeFile); dataSetGestEco1.AcceptChanges(); this.nomeFile = nomeFile; foreach (DataSetGestEco.tblProgettoRow row in dataSetGestEco1.tblProgetto) { ID = row.ID; this.Text = row.Nome + quot; - GestEcoquot;; this.statusLabel.Text = nomeFile; 43
  47. 47. } } public void progettoAperto(object sender, EventArgs e) { fineBindingSource(); if (dataSetGestEco1.HasChanges()) { string msg = quot;C'è un progetto aperto {0}quot; + quot;nVuoi salvarlo?quot;; DialogResult result = MessageBox.Show(this, String.Format(msg, nomeFile), quot;Exit Errorquot;, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2); if (result == DialogResult.Yes) { if (nomeFile == null) menuSaveAs_Click(sender, e); else menuSaveAs_Click(sender, e); } } } //-------------------------------------------------------- // PROCEDURA PER CHIUDERE TUTTI GLI EDIT DEI BINDINGSOURCE //-------------------------------------------------------- public void fineBindingSource() { this.bsAnalisiChimicheBase.EndEdit(); this.bsAnalisiChimicheGranulometria.EndEdit(); this.bsAnalisiChimicheTalQuale.EndEdit(); this.bsDatiCantiere.EndEdit(); this.bsDatiProgetto.EndEdit(); this.bsGranulometria.EndEdit(); this.bsTblAnalisiChimicheBase.EndEdit(); this.bsTblDatiProgetto.EndEdit(); this.bsTblDestinazioneMateriale.EndEdit(); this.bsTblFrazione.EndEdit(); this.bsTblProgetto.EndEdit(); this.bsTblTipoAspetto.EndEdit(); this.bsTblTipoColore.EndEdit(); this.bsTblTipoInquinante.EndEdit(); this.bsTblTipoMateriale.EndEdit(); this.bsTblTipoOdore.EndEdit(); } 44
  48. 48. //--------------------------------------------------------- // PROCEDURA PER CALCOLARE LE PERCENTUALI DELLE FRAZIONI, // DECIDERE LA FRAZIONEQUANTITà E I PROCESSI DA SELEZIONARE //--------------------------------------------------------- public void report() { //variabili per percantuali frazioni decimal qntClasse1 = 0; decimal qntClasse2 = 0; decimal qntClasse3 = 0; decimal qntClasse4 = 0; //calcolo percentuali delle frazioni foreach (DataSetGestEco.tblGranulometriaRow riga in dataSetGestEco1.tblGranulometria) { DataSetGestEco.tblClasseRow riga1 = dataSetGestEco1. tblClasse.FindByID(riga.IDClasse); switch (riga1.IDFrazione) { case 1: qntClasse1 = qntClasse1 + riga.Valore; break; case 2: qntClasse2 = qntClasse2 + riga.Valore; break; case 3: qntClasse3 = qntClasse3 + riga.Valore; break; case 4: qntClasse4 = qntClasse4 + riga.Valore; break; } } //in quale FrazioneQuantità si trova ogni Frazione? Int32 idPerClasse1 = 0; Int32 idPerClasse2 = 0; Int32 idPerClasse3 = 0; foreach (DataSetGestEco.tblFrazioneQuantitaRow riga in dataSetGestEco1.tblFrazioneQuantita) { switch (riga.IDFrazione) 45
  49. 49. { case 1: if (qntClasse1 >= riga.Min) { if (qntClasse1 < riga.Max) { idPerClasse1 = riga.ID; break; } else if (qntClasse1 == riga.Max) { idPerClasse1 = riga.ID; break; } } break; case 2: if (qntClasse2 >= riga.Min && qntClasse2 < riga.Max) idPerClasse2 = riga.ID; break; case 3: if (qntClasse3 >= riga.Min && qntClasse3 < riga.Max) idPerClasse3 = riga.ID; break; } } //quali processi vanno selezionano? foreach (DataSetGestEco. tblProcessoInFrazioneQuantitaRow riga in dataSetGestEco1.tblProcessoInFrazioneQuantita) { if (riga.IDFrazioneQuantita == idPerClasse1 || riga.IDFrazioneQuantita == idPerClasse2 || riga.IDFrazioneQuantita == idPerClasse3) { DataSetGestEco.tblProcessoRow riga1 = dataSetGestEco1.tblProcesso.FindByID(riga. IDProcesso); dataSetGestEco1.tblProcessoSelezionato. AddtblProcessoSelezionatoRow(riga1); } } } 46
  50. 50. //-------------------------------------- // PROCEDURE RIGUARDANTI I VARI PROCESSI //-------------------------------------- public void vagliatura1(DataSetGestEco. tblProcessoSelezionatoRow rigaProcesso, DataSetGestEco ds) { } public void spappolamento1(DataSetGestEco. tblProcessoSelezionatoRow rigaProcesso, DataSetGestEco ds) { } public void vaglatura2(DataSetGestEco. tblProcessoSelezionatoRow riga, DataSetGestEco ds) { } public void spappolamento2(DataSetGestEco. tblProcessoSelezionatoRow riga, DataSetGestEco ds) { } public void classificazione1(DataSetGestEco. tblProcessoSelezionatoRow riga, DataSetGestEco ds) { } public void classificazione2(DataSetGestEco. tblProcessoSelezionatoRow riga, DataSetGestEco ds) { } public void ispessimento(DataSetGestEco. tblProcessoSelezionatoRow riga, DataSetGestEco ds) { } public void disidratazione(DataSetGestEco. tblProcessoSelezionatoRow riga, DataSetGestEco ds) { } } } 47
  51. 51. 7. Bibliografia Brown, E. (2002) Windows Forms Programming With C#, Greenwich, Manning. Petzold, C. (2007) .NET Book Zero What the C or C++ Programmer Needs to Know about C# and the .NET Framework, Version 1.1. <http://www.charlespetzold.com/dotnet/DotNetBookZero11.pdf> Riordan, R. M. (2002) Microsoft ADO.NET Step By Step, Redmond, Microsoft Press. Microsoft, MSDN Library. <http://msdn.microsoft.com/it-it/library/default.aspx> 48
  52. 52. Ringraziamenti E finalmente eccomi giunto ai ringraziamenti. Non posso che iniziare con la mia famiglia: mamma e papà per l’aiuto nell’indirizzarmi su questa strada, per i sacrifici che hanno fatto per farmi giungere fino a questo momento e per la tranquillità con la quale mi hanno accompagnato in questi anni. Fabio, mio fratello, per essermi stato di stimolo anticipandomi negli studi e per la compagnia nelle noiose attese a Conegliano. Gli zii Gianni, Loris, Nicoletta, Vanda e i cugini Gio e Barbara per il sostegno e il divertimento. Un ringraziamento mescolato a ricordo per le nonne Pina e Clara scomparse negli ultimi mesi, per avermi sempre supportato e spinto. Un ringraziamento ovvio ai professori Maurizio Fermaglia e Marco Parenzan per avermi seguito nello svolgimento della tesi a
  53. 53. con pazienza e simpatia, cercando di farmi riflettere e suggerendomi la strada da seguire. Continuando non posso che ringraziare il mio amore, Valentina, per il sostegno, la poca pazienza e l’esempio diligente e per avermi stressato con il suo “devi scrivere, non hai molto tempo”. Infine, ultimi ma non ultimi tutti gli amici da Federico, compagno di molte avventure nelle nostre bellissime montagne, Samu, Laura, Sonia, Matteo C., Matteo B., Fabio, Alessandro, Andrea, John, Marco e Nicola, compagni di altre avventure (o sventure per J) in collegio e in giro per Trieste. b

×