Tesi Case Roberto
69
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:
-
Upload
guestffdfbc -
Category
Technology
-
view
1.236 -
download
2
description
Transcript of Tesi Case Roberto
UNIVERSITÀ DEGLI STUDI DI TRIESTE
____________________________________________
Facoltà di Ingegneria
CORSO DI LAUREA TRIENNALE ININGEGNERIA 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
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
i
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
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
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.
1
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
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
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
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.
4
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
5
successivo colloquio, al fine di mostrare e verificare le
funzionalità da implementare nel prodotto finale, senza
rispettare le specifiche non funzionali.
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
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.
7
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à 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.
8
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 una porzione di territorio con i relativi dati fisici e chimici
Nome Progetto, Cliente, Quantità Materiale Ton, Quantità Materiale Mc, Tipo Materiale, Codice CER, Tipo Inquinante, Destinazione Materiale, Localita, Durata, Ore Giorno, capacità Giornaliera, Capacità Oraria,Dati chimici, Dati fisici
Nome Progetto
Processo Identifica un passaggio nel trattamento di un terreno
Nome Processo, Bilancio di materia, Costi, Macchina
Nome Processo
Dizionario dei dati (relationship)
Relazione Descrizione Componenti
9
Trattamento È un insieme di processi per la lavorazione di un terreno
Terreno, Processo
Sulla base di queste tabelle è stato possibile realizzare lo
schema E-R del dataset.
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
10
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
permette di popolare il dataset automaticamente grazie ai tag
presenti all’interno del file stesso.
Di seguito viene riportato un esempio di file .xml:
11
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 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.
12
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
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.
13
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.
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
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.
3.1.1. Schede
15
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.
3.1.2. Controlli
16
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 questa sia utilizzata non per acquisire dei valori,
ma bensì per selezionare i dati da visualizzare nelle
dataGridView sottostanti.
17
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
18
applicazioni 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
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
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.
21
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
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
22
Dati di cantiere
o Località del cantiere
o Durata del cantiere
o Ore di lavoro giorno
o Capacità giornaliera di trattamento
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
23
ed i seguenti output:
Processi necessari
o Materiale in ingresso
o Materiale in uscita
Costi
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
24
partizionamento delle entità iniziali in varie tabelle è stata
fatta solo approssimativamente.
Questa fase ha sostanzialmente diviso il futuro dataset in tre
parti:
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
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
26
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
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:
27
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 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.
28
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 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
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
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
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
}
private void menuNew_Click(object sender, EventArgs e) { progettoAperto(sender, e); nuovo(); this.statusLabel.Text = "Nuovo progetto"; }
private void menuOpen_Click(object sender, EventArgs e) { progettoAperto(sender, e);
string status = this.statusLabel.Text; this.statusLabel.Text = "Apertura progetto";
//finestre di apertura progetto OpenFileDialog dlg = new OpenFileDialog(); dlg.Title = "Apri progetto"; dlg.Filter = "Xml files (*.xml)|*.xml|" + "All files (*.*)|*.*"; 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 = "Salvataggio progetto";
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 = "Salvataggio progetto";
33
//finestre per scegliere la posizione di salvataggio SaveFileDialog dlg = new SaveFileDialog(); dlg.Title = "Salva progetto"; dlg.Filter = "Xml files (*.xml)|*.xml|" + "All files|*.*"; 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 = "IDFrazione = 1"; bsGranulometria.Filter = "IDFrazione = 1"; dgGranulometria.RowsDefaultCellStyle.BackColor = Color.RoyalBlue; dgGranulometria.RowsDefaultCellStyle. SelectionBackColor = Color.RoyalBlue; break;
case 1: bsAnalisiChimicheGranulometria.Filter = "IDFrazione = 2"; bsGranulometria.Filter = "IDFrazione = 2"; dgGranulometria.RowsDefaultCellStyle. BackColor = Color.LimeGreen; dgGranulometria.RowsDefaultCellStyle. SelectionBackColor = Color.LimeGreen; break;
case 2: bsAnalisiChimicheGranulometria.Filter = "IDFrazione = 3"; bsGranulometria.Filter = "IDFrazione = 3"; dgGranulometria.RowsDefaultCellStyle. BackColor = Color.Orange; dgGranulometria.RowsDefaultCellStyle. SelectionBackColor = Color.Orange;
34
break;
case 3: bsAnalisiChimicheGranulometria.Filter = "IDFrazione = 4"; bsGranulometria.Filter = "IDFrazione = 4"; 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
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
//-----------------------------------------------------// PROCEDURA PER LA POPOLAZIONE DELLE TABELLE DI LOOKUP//----------------------------------------------------- private void LookUp() { //righe tabella tblTipoMateriale dataSetGestEco1.tblTipoMateriale. AddtblTipoMaterialeRow(1, "sedimenti"); dataSetGestEco1.tblTipoMateriale. AddtblTipoMaterialeRow(2, "terreni");
//righe tabella tblTipoInquinante dataSetGestEco1.tblTipoInquinante. AddtblTipoInquinanteRow(1, "organici"); dataSetGestEco1.tblTipoInquinante. AddtblTipoInquinanteRow(2, "inorganici"); dataSetGestEco1.tblTipoInquinante. AddtblTipoInquinanteRow(3, "misti"); dataSetGestEco1.tblTipoInquinante. AddtblTipoInquinanteRow(4, "RSAU");
//righe tabella tblDestinazioneMateriale dataSetGestEco1.tblDestinazioneMateriale. AddtblDestinazioneMaterialeRow(1, "recupero"); dataSetGestEco1.tblDestinazioneMateriale. AddtblDestinazioneMaterialeRow(2, "discarica");
//righe tabella tblComposto dataSetGestEco1.tblComposto.AddtblCompostoRow(1, "antimonio", 10, 30); dataSetGestEco1.tblComposto.AddtblCompostoRow(2, "arsenico", 20, 50); dataSetGestEco1.tblComposto.AddtblCompostoRow(3, "berilio", 2, 10); dataSetGestEco1.tblComposto.AddtblCompostoRow(4, "cadmio", 2, 15); dataSetGestEco1.tblComposto.AddtblCompostoRow(5, "cobalto", 20, 250); dataSetGestEco1.tblComposto.AddtblCompostoRow(6, "cromo totale", 150, 800); dataSetGestEco1.tblComposto.AddtblCompostoRow(7, "cromo VI", 2, 15); dataSetGestEco1.tblComposto.AddtblCompostoRow(8, "mercurio", 1, 5); dataSetGestEco1.tblComposto.AddtblCompostoRow(9, "nichel", 120, 500); dataSetGestEco1.tblComposto.AddtblCompostoRow(10, "piombo", 100, 1000); dataSetGestEco1.tblComposto.AddtblCompostoRow(11,
37
"rame", 120, 600); dataSetGestEco1.tblComposto.AddtblCompostoRow(12, "selenio", 3, 15); dataSetGestEco1.tblComposto.AddtblCompostoRow(13, "stagno", 1, 350); dataSetGestEco1.tblComposto.AddtblCompostoRow(14, "tallio", 1, 10); dataSetGestEco1.tblComposto.AddtblCompostoRow(15, "vanadio", 90, 250); dataSetGestEco1.tblComposto.AddtblCompostoRow(16, "zinco", 150, 1500); dataSetGestEco1.tblComposto.AddtblCompostoRow(17, "cianuri (liberi)", 1, 100); dataSetGestEco1.tblComposto.AddtblCompostoRow(18, "fluoruri", 100, 2000);
//righe tabella tblFrazione DataSetGestEco.tblFrazioneRow rigaFrazione1 = dataSetGestEco1.tblFrazione.AddtblFrazioneRow(1, "Classe1", "RoyalBlue"); DataSetGestEco.tblFrazioneRow rigaFrazione2 = dataSetGestEco1.tblFrazione.AddtblFrazioneRow(2, "Classe2", "LimeGreen"); DataSetGestEco.tblFrazioneRow rigaFrazione3 = dataSetGestEco1.tblFrazione.AddtblFrazioneRow(3, "Classe3", "Orange"); DataSetGestEco.tblFrazioneRow rigaFrazione4 = dataSetGestEco1.tblFrazione.AddtblFrazioneRow(4, "Classe4", "Yellow");
//righe tabella tblClasse dataSetGestEco1.tblClasse.AddtblClasseRow(1, "blocchi", rigaFrazione1, "< -8", "> 256 mm"); dataSetGestEco1.tblClasse.AddtblClasseRow(2, "ciottoli", rigaFrazione1, "-6 a -8", "64 - 256 mm"); dataSetGestEco1.tblClasse.AddtblClasseRow(3, "ghiaia molto grossa", rigaFrazione1, "-5 a -6", "32 - 64 mm"); dataSetGestEco1.tblClasse.AddtblClasseRow(4, "ghiaia grossa", rigaFrazione1, "-4 a -5", "16 -32 mm"); dataSetGestEco1.tblClasse.AddtblClasseRow(5, "ghiaia media", rigaFrazione1, "-3 a -4", "8 - 16 mm"); dataSetGestEco1.tblClasse.AddtblClasseRow(6, "ghiaia fine", rigaFrazione2, "-2 a -3", "4 - 8 mm"); dataSetGestEco1.tblClasse.AddtblClasseRow(7, "ghiaia molto fine", rigaFrazione2, "-1 a -2", "2 - 4 mm");
38
dataSetGestEco1.tblClasse.AddtblClasseRow(8, "sabbia molto grossa", rigaFrazione2, "0 a -1", "1 - 2 mm"); dataSetGestEco1.tblClasse.AddtblClasseRow(9, "sabbia grossa", rigaFrazione3, "1 a 0", "0,5 - 1 mm"); dataSetGestEco1.tblClasse.AddtblClasseRow(10, "sabbia media", rigaFrazione3, "2 a 1", "0,25 - 0,5 mm"); dataSetGestEco1.tblClasse.AddtblClasseRow(11, "sabbia fine", rigaFrazione3, "3 a 2", "125 - 250 µm"); dataSetGestEco1.tblClasse.AddtblClasseRow(12, "sabbia molto fine", rigaFrazione4, "4 a 3", "62,5 - 125 µ"); dataSetGestEco1.tblClasse.AddtblClasseRow(13, "silt (limo)", rigaFrazione4, "8 a 4", "3,9 - 62,5 µm"); dataSetGestEco1.tblClasse.AddtblClasseRow(14, "argilla", rigaFrazione4, "> 8", "< 3,9 µm"); dataSetGestEco1.tblClasse.AddtblClasseRow(15, "colloide", rigaFrazione4, "> 10", "< 1 µm");
//rghe tabella tblProcesso dataSetGestEco1.tblProcesso.AddtblProcessoRow(1, "Vagliatura grossolana", "L'operazione di vagliatura grossolana serve per eliminare i corpi grossolani fino ad un taglio di ghiaia media 16 mm"); dataSetGestEco1.tblProcesso.AddtblProcessoRow(2, "I Spappolamento", "L'operazione di spappolamento è funzione della tipologia di materiale in ingresso è assimilabile o comparabile ad un lavaggio"); dataSetGestEco1.tblProcesso.AddtblProcessoRow(3, "Vagliatura dopo spappolamento", "L'operazione di vagliatura dopo lo spappolameto permette di separe la ghiaia sabbia fino ad un taglio di ghiaia media 1- 2 mm"); dataSetGestEco1.tblProcesso.AddtblProcessoRow(4, "II Spappolamento", ""); dataSetGestEco1.tblProcesso.AddtblProcessoRow(5, "Classificazione sabbie", ""); dataSetGestEco1.tblProcesso.AddtblProcessoRow(6, "Classificazione fini", ""); dataSetGestEco1.tblProcesso.AddtblProcessoRow(7, "Ispessimento", ""); dataSetGestEco1.tblProcesso.AddtblProcessoRow(8, "Disidratazione", "");
39
//righe tabella tblFrazioneQuantita dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(1, rigaFrazione1, "", 0, 0); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(2, rigaFrazione1, "", 1, 15); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(3, rigaFrazione1, "", 15, 30); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(4, rigaFrazione1, "", 30, 100); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(5, rigaFrazione2, "", 0, 15); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(6, rigaFrazione2, "", 15, 30); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(7, rigaFrazione2, "", 30, 100); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(8, rigaFrazione3, "", 0, 15); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(9, rigaFrazione3, "", 15, 30); dataSetGestEco1.tblFrazioneQuantita. AddtblFrazioneQuantitaRow(10, rigaFrazione3, "", 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
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, "mc/h"); dataSetGestEco1.tblUM.AddtblUMRow(2, "mc/g"); dataSetGestEco1.tblUM.AddtblUMRow(3, "ton/h"); dataSetGestEco1.tblUM.AddtblUMRow(4, "ton/g"); }
//-----------------------------------------------------------// PROCEDURE PER LE CREAZIONE DELLE RIGHE RIGUARDANTI UN // NUOVO PROGETTO//----------------------------------------------------------- //riga nuovo progetto private void RigaProgetto() { DataSetGestEco.tblProgettoRow row = dataSetGestEco1.tblProgetto.AddtblProgettoRow("");
row.Nome = "Progetto" + row.ID; ID = (Int32)row.ID; }
//righe altre tabelle
41
private void RigheTabelle() { //riga tblDatiProgetto dataSetGestEco1.tblDatiProgetto. AddtblDatiProgettoRow(dataSetGestEco1. tblProgetto.FindByID(ID), "", 0, 0, null, "", null, null);
//riga tblDatiCantiere dataSetGestEco1.tblDatiCantiere. AddtblDatiCantiereRow(dataSetGestEco1. tblProgetto.FindByID(ID), "", 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
//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 + " - GestEco"; this.statusLabel.Text = nomeFile;
43
} }
public void progettoAperto(object sender, EventArgs e) { fineBindingSource();
if (dataSetGestEco1.HasChanges()) { string msg = "C'è un progetto aperto {0}" + "\nVuoi salvarlo?"; DialogResult result = MessageBox.Show(this, String.Format(msg, nomeFile), "Exit Error", 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
//---------------------------------------------------------// 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
{ 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
//--------------------------------------// 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
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
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
a
tesi 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
