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.
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.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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
• 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.
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.
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.
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.
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.
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.
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.
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.
}
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.
//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.
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.
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.
//-----------------------------------------------------
// 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.
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.
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.
//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.
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.
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.
//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.
}
}
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.
//---------------------------------------------------------
// 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.
{
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.
//--------------------------------------
// 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.
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.
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.
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