Relazione Agic

UNIVERSITÀ DEGLI STUDI DI TRIESTE

FACOLTÀ DI INGEGNERIA
Corso di Laurea in Ingegneria Informatica

Sviluppo di un software per l’importazione e gestione di
dati curricolari

Laureanda: Relatore:
Maja Agic Prof. Maurizio Fermeglia

ANNO ACCADEMICO 2007 - 2008

INDICE

1. INTRODUZIONE 2
2. TECNOLOGIE UTILIZZATE ED ANALISI 4
2.1 Tecnologie utilizzate 4
2.1.1 SQL Server Management Studio 2005 4
2.1.2 Linguaggio SQL 5
2.1.3 Microsoft Visual Studio 2005 5
2.1.4 Linguaggio C# 6
2.1.5 Formato RIS 7
2.2 Analisi 8
2.2.1 Analisi del database 8
2.2.2 Analisi del programma applicativo 9
3. REALIZZAZIONE E TEST 11
3.1 Realizzazione 11
3.1.1 Implementazione 11
3.1.1.1 Implementazione database 11
3.1.1.2 Implementazione programma applicativo 20
3.1.2 Interfaccia 35
3.1.2.1 Installazione e configurazione 35
3.1.2.2 Esempio d’uso 39
3.2 Test 47
4. CONCLUSIONI 48
4.1 Obiettivi 48
4.2 Lavoro svolto 48
4.3 Stato attuale 48
4.4 Considerazioni personali 50
5. BIBLIOGRAFIA 51

1

1 INTRODUZIONE

Un software di gestione dei dati è uno strumento che ha lo scopo di
semplificare l’interazione tra l’utente e le informazioni contenute all’interno di un
database. Il modo in cui avviene la relativa gestione e le operazioni permesse sulla
base dati dipendono dai requisiti espressi da parte del committente.
In questo testo viene descritta un’applicazione che fornisce all’utente la
possibilità di importare ed amministrare i riferimenti bibliografici legati alle
pubblicazioni professionali del personale appartenente al Dipartimento di
Ingegneria Chimica, dell'Ambiente e delle Materie Prime (DICAMP) dell’Università
degli Studi di Trieste. Inoltre, sarà illustrato il database sottostante.
Il sistema sviluppato (il database e l’applicazione) è stato creato per esigenze
di raccolta sistematica dei riferimenti alle pubblicazioni appartenenti alle suddette
persone ed alla loro raggiungibilità dal sito internet del DICAMP, più precisamente
http://www.dicamp.units.it/Research/Publications/default.aspx .
Questo sito dispone già di una raccolta dei riferimenti alle pubblicazioni, il che
vuole dire che il sistema qui descritto andrà a sostituire la vecchia modalità di
visualizzazione. La vecchia raccolta dei riferimenti permetteva solamente la
visualizzazione dei dati relativi alle pubblicazioni che si trovano in un file statico
HTML. Con il nuovo sistema i dati da visualizzare andranno prelevati dal database
sottostante, ed inoltre ci sarà la possibilità di filtrare i riferimenti da visualizzare per
autore, e i dati potranno essere importati nel database da file RIS. I dati sul sito
saranno visualizzati in maniera simile a quella delle pubblicazioni sul sito
http://www.mose.units.it/ .
Tutto questo è stato realizzato utilizzando fondamentalmente due ambienti di
sviluppo. “SQL Server 2005” per il database ed il “Microsoft Visual Studio 2005” (che
incorpora il .NET Framework 2.0) per l’applicazione. Tutti i moduli che compongono
l’applicazione sono stati scritti in linguaggio C#, uno dei linguaggi con il quale è
possibile programmare in “MS Visual Studio 2005”.
Lo sviluppo di questo sistema non sarebbe stato possibile senza uno studio
preliminare sia sulle tecnologie utilizzate, sia sul formato dati da importare. Una
volta completata la parte preliminare si è iniziato con l’analisi degli obiettivi del
committente, la quale ha avuto come risultato la definizione degli requisiti che il
sistema avrebbe dovuto soddisfare. Arrivati al punto dove gli requisiti sono ben
inquadrati si è potuto procedere con la progettazione, seguita dalla fase di
realizzazione. Quando la parte creativa del lavoro è stata terminata ha avuto l’inizio
la fase di test. L’oggetto di questo testo sarà descrivere in dettaglio ognuna di
queste fasi che hanno portato al risultato finale. Intanto segue una breve
introduzione alle stesse.

2

Le tecnologie studiate:

• SQL Server Management Studio 2005
• Linguaggio SQL
• Microsoft Visual Studio 2005
• Linguaggio C#
• Formato RIS

Analisi:

L’analisi dei bisogni ed obiettivi consisteva fondamentalmente nell’apprendere le
esigenze che progetto da sviluppare dovrà soddisfare, dalle quali è stato possibile
determinare quali dati dovrà contenere il database, le prime grezze idee sulla
visualizzazione dei dati nell’applicazione, nonché le operazioni da permettere
all’utente.

Realizzazione:

Questa fase si occupa della progettazione e sviluppo vero e proprio del database, e
dei moduli del programma applicativo.
La prima parte di realizzazione descritta, viene chiamata “implementazione”. Qui si
è occupati del disegno logico delle singole tabelle del database, delle loro relazioni e
vicoli. Fatto ciò, ci siamo occupati anche del descrivere il funzionamento dei vari
“form” che saranno la parte interattiva del sistema. Questa parte contiene anche
porzioni di codice dei metodi ritenuti più importanti. Infine abbiamo riportato un
diagramma di flusso finale di tutto il programma applicativo.
La seconda parte di realizzazione descrive l’interfacciamento dell’utente col
programma. In questa sezione viene spiegata la modalità di installazione e
configurazione del sistema, nonché riportato un esempio di utilizzo del sistema con
le immagini delle schermate e le spiegazioni che le accompagnano.

Test:

I test funzionali sono stati eseguiti sia dopo la codifica di ogni modulo, per accertarsi
che il modulo esegua correttamente la propria funzione, sia dopo l’unione dei
moduli.

3

2 TECNOLOGIE UTILIZZATE ED ANALISI
2.1 Tecnologie utilizzate

2.1.1 SQL Server Management Studio 2005

È un ambiente integrato per l’accesso, configurazione, gestione e sviluppo di tutti i
componenti di SQL Server. Esso unisce un vasto gruppo di tool grafici ed una serie di
rich script editor con lo scopo di fornire l’accesso a SQL Server agli sviluppatori ed
amministratori di tutti i livelli di abilità. SQL Server Management Studio unisce le
funzionalità di Enterprise Manager, Query Analyzer e Analysis Manager inclusi nelle
precedenti versioni di SQL Server, in un unico ambiente. Inoltre, SQL Server
Management Studio funziona con tutti i componenti di SQL Server come Reporting
Services, Integration Services e SQL Server Compact 3,5 SP1. In questo modo gli
sviluppatori possono approfittare delle esperienze familiari, e gli amministratori di
database hanno a loro disposizione un utility unico e completo che unisce gli tools
grafici di facile impiego con le capacità di rich scripting.

4

2.1.2 Linguaggio SQL

Il linguaggio SQL (Structured Query Language) è un linguaggio di tipo non
procedurale che consente di operare sui dati di un database tramite frasi che non
fanno uso di simboli matematici ed algebrici, ma solo di parole chiave prese dal
linguaggio corrente. Questo, insieme alla sintassi che riprende forme usuali, fa sì che
le frasi abbiano una struttura lineare ed espressiva. In particolare il termine
Structured (strutturato) di SQL è riferito al fatto che si può inserire un'interrogazione
all'interno di un'altra interrogazione; più in generale si parla di query innestate.
SQL è il linguaggio per la definizione dei dati. Le tre istruzioni che permettono la
definizione dei dati: CREATE, ALTER, DROP.
Esso è pure un linguaggio per la manipolazione dei dati, la quale è possibile
attraverso le quattro istruzioni: SELECT (segue esempio), INSERT, UPDATE, DELETE.
Ed infine, è il linguaggio di controllo dei dati: GRANT, REVOKE.

Esempio della istruzione select:

L'istruzione SELECT serve per estrarre informazioni dal database.
La sua sintassi è la seguente:

SELECT [ ALL | DISTINCT ] lista_scelte
FROM lista_tabelle
[WHERE condizioni]
[GROUP BY lista_attributi ]
[HAVING condizioni ]
[ ORDER BY lista_attributi ]

2.1.3 Microsoft Visual Studio 2005

È un ambiente di sviluppo integrato (Integrated Development Environment o IDE)
sviluppato da Microsoft, che supporta diversi tipi di linguaggio, quali C++, C#, J#,
Visual Basic .Net e ASP .Net, e che permette la realizzazione di applicazioni, siti web,
applicazioni web e servizi web. È inoltre un RAD (Rapid Application Development),
ovvero una applicazione atta ad aumentare la produttività aiutando il
programmatore con mezzi come l'IntelliSense o un designer visuale dei form. Visual
Studio .NET è inoltre multipiattaforma: con esso è possibile realizzare programmi
per server, workstation, pocket PC, smartphone e, naturalmente, per i browser.
5

2.1.4 Linguaggio C#

Il C# è un linguaggio di programmazione orientato ad oggetti, sviluppato da
Microsoft all'interno dell'iniziativa .NET, e successivamente approvato come
standard ECMA. La sintassi del C# prende spunto da quella del Delphi (hanno il
medesimo autore), del C++, da quella di Java ed a Visual Basic per gli strumenti di
programmazione visuale e per la sua semplicità (meno simbolismo rispetto a C++,
meno elementi decorativi rispetto a Java).
Esempio 1 - stampa su schermo “Hello World”
using System;
class HelloWorldApp
{
public static void Main()
{
Console.WriteLine(quot;Hello Worldquot;);
}
}

6

Esempio 2 - definisce la classe Persona
using System;
namespace Program
{
class Persona
{
public string Nome
{
get { return mNome; }
set { mNome = value; }
}
private string mNome;
}
}

2.1.5 Formato RIS

Il formato RIS è un “tag format” standardizzato, sviluppato da “Research
Information Systems, Incorporated” per permettere lo scambio di dati tra i
programmi di citazioni. Il formato di file -- due lettere, due spazi ed il trattino -- è il
formato “taggato” per esprimere i riferimenti bibliografici. È supportato da vari
gestori di riferimenti. Tante biblioteche digitali, come IEEE Xplore, Scopus, ACM
Portal, e SpringerLink sono in grado di esportare i propri riferimenti in questo
formato. Le spiegazioni dei tag:
TY - Type of reference (must be the first tag) J2 - Periodical name - User abbreviation 2
ID - Reference ID (not imported to reference VL - Volume number
software) IS - Issue number
T1 - Primary title T2 - Title secondary
TI - Book title CY - City of Publication
CT - Title of unpublished reference PB - Publisher
A1 - Primary author U1 - User definable 1
A2 - Secondary author (each name on separate line) U5 - User definable 5
AU - Author (syntax. Last name, First name, Suffix) T3 - Title series
Y1 - Primary date N2 - Abstract
PY - Publication year (YYYY/MM/DD) SN - ISSN/ISBN (e.g. ISSN XXXX-XXXX)
N1 - Notes AV - Availability
KW - Keywords (each keyword must be on separate M1 - Misc. 1
line preceded KW -) M3 - Misc. 3
RP - Reprint status (IN FILE, NOT IN FILE, ON AD - Address
REQUEST (MM/DD/YY)) UR - Web/URL
SP - Start page number L1 - Link to PDF
EP - Ending page number L2 - Link to Full-text
JF - Periodical full name L3 - Related records
JO - Periodical standard abbreviation L4 - Images
JA - Periodical in which article was published ER - End of Reference (must be the last tag)
J1 - Periodical name - User abbreviation 1

7

Esempio di come quot;Claude E. Shannon. A mathematical theory of communication.
Bell System Technical Journal, 27:379–423, July 1948quot; sarebbe espresso in questo
formato:

TY - JOUR
AU - Shannon, Claude E.
PY - 1948/07//
TI - A Mathematical Theory of Communication
JO - Bell System Technical Journal
SP - 379
EP - 423
VL - 27
ER -

2.2 Analisi
L’analisi parte dai bisogni del committente. Questi dovranno essere soddisfatti dal
sistema che andiamo a sviluppare. La parte di analisi si conclude con la definizione di
requisiti. In questo paragrafo verrà illustrato il procedimento di analisi seguito, sia
per il database, sia per quanto riguarda il programma applicativo che andrà ad
utilizzare i dati contenuti nel database.

2.2.1 Analisi del database

• Descrizione degli obiettivi

Il database deve contenere le informazioni riguardanti il personale del
DICAMP ed i riferimenti bibliografici degli ultimi. Per quanto riguarda il
personale, a parte il nome e cognome di ogni membro, il database deve
tenere traccia anche dello stato (attivo/non attivo) dei membri, username,
appartenenza a qualche gruppo interno al dipartimento, ed inoltre deve
fornire l’informazione se la determinata persona è un amministratore del
database. L’unico dato tra questo che può mancare è il username. Prendendo
in considerazione invece gli riferimenti bibliografici, ci interessa memorizzare
il tipo di riferimento, il titolo, gli autori, l’anno di pubblicazione, il nome ed il
volume della rivista dov’è uscita la pubblicazione, la pagina iniziale e finale.
Inoltre, c’è bisogno di un campo che formatterà i seguenti dati nel seguente
modo → volume:pagina iniziale - pagina finale (anno di pubblicazione). Ogni
riferimento deve essere associato ad uno o più membri del personale.
8

Ogni persona deve appartenere ad un gruppo. Una persona non può
appartenere a più di un gruppo. Esiste anche il gruppo chiamato “nessuno”,
del quale fanno parte solo le persone che non appartengono a nessun altro
gruppo. Il dato, “tipo di riferimento”, è un’abbreviazione che deve avere una
spiegazione comprensibile per un utente non esperto di abbreviazioni
bibliografiche del formato RIS. Ogni pubblicazione deve avere un tipo definito,
e non ne può avere più di uno.

• Glossario

Per evitare possibili ambiguità sui termini viene creato il glossario. Esso spiega
tutti i principali termini utilizzati nella descrizione degli obiettivi.

RIFERIMENTO Una collezione di dati che descrivono una pubblicazione
PERSONA Individuo appartenete al personale del DICAMP ed
autore di almeno una pubblicazione, oppure
l’amministratore
GRUPPO Un insieme di persone. È dotato di un nome.
AUTORI Tutti gli autori della pubblicazione, sia le persone del
DICAMP, sia autori esterni. È una stringa concatenata con
il simbolo “;”
RIVISTA Il giornale nel quale è stato pubblicato l’articolo
ANNO PUBBLICAZIONE L’anno dell’uscita della pubblicazione alla quale ci si
riferisce
PAGINA INIZIALE Il numero di pagina dove si trova l’inizio dell’articolo nella
rivista
PAGINA FINALE Il numero di pagina dove si trova la fine dell’articolo nella
rivista

2.2.2 Analisi del programma applicativo

• Descrizione degli obiettivi

Il programma applicativo ha lo scopo di permettere all’utente di interfacciarsi
col database in un modo semplice ed intuitivo. Il suo compito è:
- la importazione dei riferimenti nel database a partire da un file in formato
RIS
- permettere all’utente di associare il riferimento alle persone

9

- permettere all’utente di modificare tutti i dati del riferimento, tranne il
tipo di pubblicazione, prima del salvataggio dello stesso nel database
- la visualizzazione di tutti i riferimenti associati ad una determinata
persona, con la possibilità di:
- cancellazione di ogni singolo riferimento
- modifica del riferimento selezionato
- associazione dissociazione delle persone ad da un determinato
riferimento

• Bozza del diagramma di flusso dell’applicazione

Ora siamo in grado di costruire una prima bozza del diagramma di flusso che
esprime in modo sintetico i requisiti che l’applicativo dovrà soddisfare.

INIZIO

AMMINISTRAZIONE IMPORTAZIONE

VISUALIZZAZIONE DI TUTTI I
RIFERIMENTI DELLA PERSONA
MODIFICHE PRIMA
DEL SALVATAGGIO

MODIFICHE SINGOLO
RIFERIMENTO

FINE
FINE

10

3 REALIZZAZIONE E TEST

3.1 Realizzazione

La parte di realizzazione è formata da due parti che saranno spiegate in seguito. La
parte di implementazione e la parte di interfaccia.

3.1.1 Implementazione

Questa parte spiega come è stato progettato il database e l’applicativo. Per
progettare un database, partendo dai requisiti determinati al punto precedente si
procede con la progettazione concettuale, la quale ha come risultato il diagramma
delle entità e relazioni → Entity - Relationship(E-R) Diagram. L’implementazione
dell’applicativo invece determina i contenuti dei singoli moduli che costituiscono il
programma finale, e la modalità di funzionamento del tutto.

3.1.1.1 Implementazione database

Le caratteristiche del database, determinate a partire dai requisiti, che
servono al disegno del diagramma E-R:

• Determinazione delle entità

ENTITA’

Personale
Gruppo
Tipo Riferimento
Riferimento

11

• Analisi delle entità

→ Elenco attributi

PERSONALE GRUPPO RIFERIMENTO

ID_Gruppo ID_Riferimento
ID_Personale
Nome Titolo
Cognome
Note Autori
Nome
Anno_Pubblicazione
Attivo
Pag_iniz
Username
Pag_fin
Amministratore
TIPO RIFERIMENTO Rivista
Volume
ID_TipoRif Riferimento_veloce
RisTAG
TipoPubblicazione

→ Descrizione degli attributi

TIPO RIFERIMENTO
ATTRIBUTO DESCRIZIONE

Numero che identifica univocamente un tipo di riferimento
ID_TipoRif

Il tag utilizzato nel file RIS per identificare un tipo di riferimento
RisTAG

La spiegazione testuale del RisTAG
TipoPubblicazione

12

GRUPPO

Numero che identifica univocamente un gruppo
ID_Gruppo

Il nome del gruppo appartenente al DICAMP
Nome

Ulteriori informazioni
Note

RIFERIMENTO

Numero che identifica univocamente il riferimento
ID_Riferimento

Il titolo del riferimento
Titolo

Tutti gli autori della pubblicazione, sia le persone del DICAMP, sia autori esterni
Autori

L’anno nel quale è uscita la pubblicazione alla quale il riferimento si riferisce
Anno_Pubblicazione

Il numero di pagina dove si trova l’inizio dell’articolo nella rivista
Pag_iniz

Il numero di pagina dove si trova la fine dell’articolo nella rivista
Pag_fin

Il nome del giornale nel quale è stato pubblicato l’articolo
Rivista

Il volume della rivista dove è stato pubblicato l’articolo
Volume

volume:pagina iniziale - pagina finale (anno di pubblicazione)
Riferimento_veloce

13

PERSONALE

Numero che identifica univocamente una persona
ID_Personale

Il cognome della persona
Cognome

Il nome della persona
Nome

Lo stato corrente della persona
Attivo

Il codice della persona
Username

La persona che amministra il database
Amministratore

→ Vincoli sugli attributi

TIPO RIFERIMENTO
ATTRIBUTO CHIAVE TIPO VALORE NULL

Chiave Primaria (PK) Integer Non permesso
ID_TipoRif

No String Permesso
RisTAG

No String Permesso
TipoPubblicazione

14

GRUPPO

ID_Gruppo

No String Permesso
Nome

No String Permesso
Note

RIFERIMENTO

ID_Riferimento

Parte di una Chiave Unica (IX) String Permesso
Titolo

No String Permesso
Autori

No Integer Permesso
Anno_Pubblicazione

No Integer Permesso
Pag_iniz

No Integer Permesso
Pag_fin

Rivista

Volume

Riferimento_veloce

15

PERSONALE

ID_Personale

No String Non permesso
Cognome

No String Non permesso
Nome

No Integer Non permesso
Attivo

No String Permesso
Username

No Bool Non permesso
Amministratore

• Determinazione delle relazioni

RIFERIMENTO PERSONALE GRUPPO

TIPO
RIFERIMENTO

16

• Analisi delle relazioni

→ Cardinalità delle relazioni

ENTITA’ ENTITA’ CARDINALITA’

Riferimento Personale Molti a Molti

Personale Gruppo Uno a Molti

Riferimento Tipo Riferimento Uno a Molti

17

• Diagramma E-R

ID_Riferimento

Attivo
Username
Rivista
Pag_iniz
Volume
Pag_fin Cognome Nome

PERSONALE 0-N
0-N
RIFERIMENTO PERSONALE
AUTORE

Anno_Pubblicazione
0-1 1-1

Titolo

Autori Riferimento_veloce ID_Personale Amministratore

RAGGRUPPA-
TIPIZZAZIONE
MENTO

ID_Gruppo
ID_TipoRif TipoPubblicazione Nome

0-N 0-N

TIPO
GRUPPO
RisTAG Note
RIFERIMENTO

18

• Schema fisico

Lo schema fisico viene creato traducendo il diagramma E-R. Le entità diventano
tabelle del database fisico. Qui abbiamo una tabella in più, ed è quella che
rappresenta la relazione “Personale Autore”, che lega la tabella “Riferimento” con la
tabella “Personale”. È stata chiamata “tblRif_Pers”. Infine si aggiungono tutte le
relazioni tra le tabelle, attraverso la definizione delle chiavi primarie e chiavi
esterne. Lo schema fisico del nostro database viene illustrato in seguito.

19

3.1.1.2 Implementazione programma applicativo

Il programma applicativo è suddiviso in moduli. Ogni modulo rappresenta un
form. Partendo dalla bozza del diagramma di flusso, determinato alla conclusione
della parte di analisi, la si elabora ulteriormente, affinché tutti i moduli non sono
completamente definiti. Qui verrà descritto il funzionamento interno dei moduli
principali del programma ed il loro funzionamento intrinseco, mentre nella parte di
interfaccia, che verrà in seguito, ci focalizzeremo sul funzionamento dal punto di
vista dall’utente.
I moduli principali sono:

• PRINCIPALE
• IMPORTAZIONE
• RIFERIMENTI
• DETTAGLI
• AMMINISTRAZIONE
• MODIFICA_PUBBLICAZIONE

PRINCIPALE

Il modulo chiamato “Principale” è il modulo radice. Contiene due bottoni, i quali
sono collegati con i prossimi due moduli principali, che biforcano il flusso del
programma. Sostanzialmente, premendo uno dei due bottoni, si crea l’oggetto della
classe che definisce il form scelto e lo si visualizza su schermo.
Esempio che mostra la porzione di codice del funzionamento di uno dei due
bottoni:

private void button3_Click(object sender, EventArgs e) // bottone ”Importa”
{ // cliccato
Importazione imp = new Importazione();
imp.Show();
}

20

IMPORTAZIONE

Questo modulo ci da la possibilità di cercare il file RIS nel PC, e di richiamare il
prossimo modulo principale, quello di nome “Riferimenti”. Quindi ha il bottone di
nome “Sfoglia”, che crea un oggetto della classe
“System.Windows.Forms.OpenFileDialog”, setta l’estensione predefinita a “.ris”, ed
il path iniziale diventa quello del Desktop del Localhost. Quindi i settings del file
dialog sono:

fd.DefaultExt = quot;risquot;; // fd è il riferimento all’oggetto della classe OpenFileDialog
fd.FileName = quot;*.risquot;;
fd.Filter = quot;quot;RisFiles|*.risquot;quot;;
fd.InitialDirectory=System.Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
fd.Title = quot;Cercaquot;;
fd.FileOk += new System.ComponentModel.CancelEventHandler(this.openFileDialog1_FileOk);

Il nome del file RIS selezionato viene inserito nella textbox del form “Importazione”.
Premendo il bottone “Apri”, viene aperto in lettura il file RIS del nome specificato
nella textbox, e viene creato l’oggetto “Riferimenti” ed invocato il metodo
“mostra_Riferimenti”, che mostra il form dove in automatico vengono inseriti tutti i
riferimenti alle pubblicazioni che il file RIS contiene. Nel caso l’apertura del file non
termina con successo, viene gestita l’eccezione visualizzando un form di errore su
schermo che informa l’utente dell’apertura non avvenuta e gli suggerisce di
ricontrollare il nome del file.

RIFERIMENTI

Nella listbox del form riferimenti vengono visualizzati tutti i riferimenti che contiene
il file RIS dal quale siamo andati a leggere. Una riga per ogni riferimento. Non
vengono visualizzati tutti i dati che lo riguardano, ma solamente il titolo, rivista ed
autori. Questa visualizzazione viene ottenuta leggendo il file RIS. Visto che un file RIS
di solito contiene più di un riferimento, ci si ferma su ogni tag TY, il quale identifica il
tipo del riferimento, ed è sempre il primo tag della pubblicazione. Fermati qui, viene
creata una stringa concatenata, man mano che si continua a leggere riga per riga il
file, concatenando solamente il testo che segue i tag T1 o TI per il titolo, A1, A2, AU
per gli autori, JF, JO, JA per il nome della rivista. Nel caso dell’esistenza di più tag per
il medesimo concetto (ad es. esiste sia T1 che TI ), viene concatenato solamente il
testo che segue il primo tag incontrato.
21

Segue il codice del metodo “mostra_Riferimenti”che effettua quanto appena detto:

public void mostra_Riferimenti(Stream st, int x)
{
TextReader tr;
try
{
tr = new StreamReader(st); // apre lo stream di lettura dal file
string conc = quot; *quot;;
string prima;
int i = 0;
int j = 0;
int k = 0;
prima = tr.ReadLine();
while (prima != null) // ciclo di concatenazione della stringa
{ // man mano che il file viene letto
if (prima.StartsWith(quot;TYquot;))
{
i = 0; j = 0;
k = k + 1;
if (k > 1 && k != (x + 2))
this.listBox_mia.Items.Add(conc);
conc = quot; *quot;;
}
if (prima.StartsWith(quot;T1quot;) || prima.StartsWith(quot;TIquot;))
{
i = i + 1;
if (i == 1)
conc = conc + prima.Substring(6) + quot;** quot;;
}
if (prima.StartsWith(quot;A1quot;) || prima.StartsWith(quot;A2quot;) || prima.StartsWith(quot;AUquot;))
conc = conc + prima.Substring(6) + quot; | quot;;
if (prima.StartsWith(quot;JFquot;) || prima.StartsWith(quot;JOquot;) || prima.StartsWith(quot;JAquot;))
{
j = j + 1;
if (j == 1)
conc = conc + quot;(quot; + prima.Substring(6) + quot;);quot;;
}
prima = tr.ReadLine();
}

this.listBox_mia.Items.Add(conc);
tr.Close();
this.Show();
} // continua sulla pagina successiva

22

catch (Exception e)
{
Errore_File ef = new Errore_File(); // mostra il messaggio d’errore
ef.Show();
}
}

Facendo doppio click sul riferimento che si desidera importare, viene creato
l’oggetto della classe “Dettagli” e viene invocato il metodo “trova_Record” della
medesima classe. Questo metodo va a leggere nuovamente il file RIS in ricerca del
riferimento desiderato e visualizza tutti i dati del riferimento.

DETTAGLI

Questo modulo crea il form dove vengono visualizzati tutti i dati che riguardano il
riferimento desiderato. Essi sono mostrati in formato stringa nei rispettivi testbox,
unicamente identificati da una label affianco. Tutti i textbox permettono la modifica
diretta del dato(stringa), tranne quello con la label “Tipo Riferimento”, visto che si è
ritenuto non opportuno dare la possibilità di modificare questo campo all’utente, in
quanto non ce ne bisogno, e potrebbe portare solamente danni, causa errori umani.
Il codice del metodo “trova_Record” che ha il compito di riempire le textbox a
partire dal file RIS:

public void trova_Record(int x, Stream st,int ind)
{
num_riga = ind;
TextReader tr = new StreamReader(st);
int count = 0;
int i = 0;
int j = 0;
int k = 0;
x = x + 1;
string autori = quot;quot;;
string line;

while (count < x) // il ciclo che legge il file finché non incontra il record
{ // desiderato. Quando lo trova inserisce il Tipo di
line = tr.ReadLine(); // riferimento nella textbox corrispondente

// continua sulla pagina successiva

23

if (line.StartsWith(quot;TYquot;))
{
count = count + 1;
textBox1.Text = line.Substring(6);
}
}
do // il ciclo che inserisce tutti i dati del riferimento, tranne il tipo di riferimento
{ // nelle textbox corrispondenti
line = tr.ReadLine();
if (line == null) break;
if (line.StartsWith(quot;T1quot;) || line.StartsWith(quot;TIquot;))
{
i = i + 1;
if (i == 1)
}
if (line.StartsWith(quot;A1quot;) || line.StartsWith(quot;A2quot;) || line.StartsWith(quot;AUquot;))
autori = autori + line.Substring(6) + quot;;quot;;
if (line.StartsWith(quot;JFquot;) || line.StartsWith(quot;JOquot;) || line.StartsWith(quot;JAquot;))
{
j = j + 1;
if (j == 1)
}
if (line.StartsWith(quot;VLquot;))
if (line.StartsWith(quot;PYquot;) || line.StartsWith(quot;Y1quot;))
{
k = k + 1;
if (k == 1)
{
textBox6.Text = line.Substring(6, 4);
}
}

if (line.StartsWith(quot;SPquot;))
if (line.StartsWith(quot;EPquot;))
}

while (!line.StartsWith(quot;TYquot;));
textBox3.Text = autori;
tr.Close();
this.Show();
}

24

In più, ci sono anche due listbox. Una dove all’apertura del form vengono visualizzati
tutti i record della tabella “Persone” in ordine alfabetico, più precisamente, la
stringa concatenata di cognome e nome della persona. L’altra listbox è inizialmente
vuota. Selezionando la persona o le persone desiderate, dalla prima listbox, e
premendo il bottone con la freccia che punta verso la listbox vuota, si fa in modo
che le righe selezionate spariscono da una listbox ed appaiono nell’altra. Inoltre poi,
è possibile fare l’identica operazione al contrario. Tutto questo ha lo scopo di
permettere all’utente di associare il riferimento alle persone che sono gli autori
della pubblicazione alla quale il riferimento si riferisce.
Schiacciando il bottone “Importa”, viene aperta una connessione con il database del
sistema, il quale si chiama “pubblicazioni”, e viene aggiunto un nuovo record alla
tabella “tblRiferimento”, salvando nei rispettivi campi i valori delle textbox. Se
mancano i dati che dovrebbero andare inseriti nei campi “Volume”, “Pag_iniz” e
“Pag_fin”, al loro posto viene inserito il valore “1”. Inoltre viene calcolato ed inserito
il valore per il campo “Riferimento_veloce”, con la seguente concatenazione di
stringa: stringRiferimento_veloce= Volume + ”:” + pag_iniz + “ - “ + pag_fin + “(“ +
Anno_Pubblicazione + “)”;
Prima di chiudere le connessione col database, viene aggiunto un nuovo record nella
tabella “tblRif_Pers” per ogni persona associata al riferimento nella listbox al punto
precedente.
Se tutto è andato a buon fine, viene chiuso il form “Dettagli” e creato l’oggetto della
classe “Importazione_Riuscita”, attraverso il quale si visualizza il form che informa
l’utente che l’importazione è terminata con successo. Nello stesso momento, viene
cancellata la riga del riferimento appena importato dalla listbox del form
“Riferimenti”, per evitare che l’utente importi più volte lo stesso riferimento per
errore.
Se qualcosa ha generato un’eccezione nello scaricamento dati nel database, viene
visualizzato il form di errore informando l’utente che l’importazione non è riuscita,
ed indicando i possibili motivi grazie ai quali non è stato possibile importare.
Questo avviene creando l’oggetto della classe “Errore_Importazione” ed
applicandogli il metodo “Show()”.
In seguito è riportato il codice del funzionamento nel bottone “Importa” con il quale
i dati vengono importati nel database:
private void button3_Click(object sender, EventArgs e)
{
string s=Application.StartupPath+quot;SettingsstringaConnessione.txtquot;; // file della stringa
if (!File.Exists(s)) // di connessione
{
Errore_Apertura_File_Connessione ef = new Errore_Apertura_File_Connessione();
ef.Show();
}

25

else // per poter connettersi al DB bisogna includere la libreria System.Data.SqlClient
{
try
{
TextReader tr= new StreamReader(s);
string source=tr.ReadLine(); // legge la stringa di connessione dal file
SqlConnection conn= new SqlConnection(source);
conn.Open(); // apre la connessione col DB
string risTag= quot;SELECT ID_TipoRif FROM tblTipoRif WHERE RisTAG='quot; + this.textBox1.Text + quot;'quot;;
SqlCommand cmd1 = new SqlCommand(risTag, conn);
int tagRis = (int)cmd1.ExecuteScalar(); // esegue la query che torna il valore del ID_TipoRif
string titolo = this.textBox2.Text;
string autori = this.textBox3.Text;
string rivista = this.textBox4.Text;
string riferimento_veloce=quot;quot;;
if (titolo.Contains(quot;'quot;))
titolo = titolo.Replace(quot;'quot;, quot; quot;);
if (autori.Contains(quot;'quot;))
autori = autori.Replace(quot;'quot;, quot; quot;);
if (rivista.Contains(quot;'quot;))
rivista = rivista.Replace(quot;'quot;, quot; quot;);
string insert = quot;INSERT INTO tblRiferimento (ID_TipoRif, Titolo, Autori,Rivista,Volume,quot; +
quot;Anno_Pubblicazione,Pag_iniz,Pag_fin,Riferimento_veloce) VALUES (quot; +
tagRis + quot;,'quot; + titolo + quot;','quot; + autori + quot;','quot; +
rivista + quot;'quot;;
if (this.textBox5.Text != quot;quot;)
{
insert = insert + quot;,'quot; + this.textBox5.Text+quot;'quot;;
riferimento_veloce = this.textBox5.Text+quot;:quot;;
}
else
{
insert = insert + quot;,'1'quot;;
riferimento_veloce = quot;1:quot;;
}
{
insert = insert + quot;,quot; + this.textBox6.Text;
}
else
{
insert = insert + quot;,nullquot;;
}
{
riferimento_veloce = riferimento_veloce + this.textBox7.Text+quot;-quot;;
}

26

else
{
insert = insert + quot;,1quot;;
riferimento_veloce = riferimento_veloce + quot;1-quot;;
}
{
riferimento_veloce = riferimento_veloce + this.textBox8.Text;
}
else
{
insert = insert + quot;,1quot;;
riferimento_veloce = riferimento_veloce + quot;1quot;;
}
riferimento_veloce = riferimento_veloce + quot;(quot;+this.textBox6.Text+quot;)quot;;
insert = insert +quot;,'quot;+riferimento_veloce+ quot;')quot;;
cmd1 = new SqlCommand(insert, conn); // inserisce un nuovo record nella tabella “tblRiferimento”
cmd1.ExecuteNonQuery(); // con i dati delle textbox
string id = quot;SELECT MAX(ID_Riferimento) FROM tblRiferimentoquot;;
cmd1 = new SqlCommand(id, conn);
int id_rifer = (int)cmd1.ExecuteScalar(); // esegue la query che torna ID del riferimento appena inserito
int num_autori= this.listBox1.Items.Count;
System.Windows.Forms.ListBox.ObjectCollection oc=this.listBox1.Items;
int count = oc.Count;
Object[] ob_c = new Object[count];
oc.CopyTo(ob_c,0);
char[] spazio= new char[1];
spazio[0]=',';
while (num_autori>0) // il ciclo che associa il riferimento alle persone desiderate
{
String[] str_cogn_nom =this.listBox1.GetItemText(ob_c[num_autori-1]).Split(spazio[0]);
string id_auth= quot;SELECT ID_Personale FROM tblPersonale WHERE quot;+
quot;Cognome=' quot;+str_cogn_nom[0]+ quot; ' AND Nome='quot;+str_cogn_nom[1]+quot;'quot;;
cmd1 = new SqlCommand(id_auth, conn); //esegue la query che torna ID della Persona da
int id_pers = (int)cmd1.ExecuteScalar(); // associare
string ins_auth= quot;INSERT INTO tblRif_Pers(ID_Rif,ID_Personale)quot; +
quot;VALUES (quot;+id_rifer+quot;,quot;+id_pers+quot;)quot;;
cmd1 = new SqlCommand(ins_auth, conn);
cmd1.ExecuteNonQuery(); // inserisce la coppia ID_Riferimento, ID_Persona alla tblRif_Pers
num_autori=num_autori-1;
}
conn.Close(); // chiude la connessione
rif_interno.refresh(num_riga); // chiama il metodo refresh che toglie la riga del riferimento importato
Importazione_Riuscita ir =new Importazione_Riuscita(det_esterno,rif_interno);//dal form “Riferimenti”
ir.Show(); // mostra il form che informa l’utente della importazione terminata con successo
}
catch (Exception err)
{
Errore_Importazione eimp = new Errore_Importazione();
eimp.Show(); // mostra il form dell’errore nella importazione
}
} }

27

AMMINISTRAZIONE

Come è possibile intuire dal nome stesso di questo modulo, esso ci permette di
amministrare i riferimenti salvati nel database. Appena viene creato l’oggetto di
questa classe, viene stabilita la connessione col database attraverso la quale viene
riempita la combo box con i cognomi e nomi di tutti i record nella tabella
“tblPersonale”. Scegliendo la persona desiderata, e successivamente schiacciando il
bottone “Mostra”, viene visualizzato il gruppo di appartenenza della persona scelta
in una textbox non soggetta a modifiche. Questo accade eseguendo la query sulla
tabella “tblPersonale” che restituisce il valore del campo “ID_Gruppo”.
Successivamente viene eseguita la seconda query che torna il valore del campo
“Nome” della “tblGruppo”. A parte questo, la listbox contenuta nel form
“Amministrazione” viene riempita nell’ordine alfabetico con i riferimenti associati
alla persona in questione. Queste righe di riferimenti sono le stringhe concatenate
dei seguenti campi: Titolo, Autori, Rivista, Riferimento_veloce.
Da qui è possibile selezionare un riferimento nella listbox e cancellarlo premendo il
bottone “Cancella pubblicazione”. Il riferimento viene dissociato dalla persona nel
database e dalla listbox nel form corrente.
Se si desidera invece modificare i dati del riferimento, si seleziona il riferimento
desiderato e si schiaccia il bottone “Modifica pubblicazione”. Facendo così
eseguiamo una query che prende i dati dei campi “Titolo”, “Autori”, “Rivista”,
“Riferimento_veloce” separando opportunamente la stringa selezionata nella
listbox, e ci restituisce il valore del campo “ID_Riferimento”. Questo è possibile per
via della esistenza della chiave unica nella base dati che comprende i campi “Titolo”,
“Rivista”, “Volume”, “Riferimento_veloce”. Non è stato possibile aggiungere il
campo “Autori” alla chiave per via del limite di lunghezza massimo della chiave.
Comunque si è ritenuto che non possono esistere due riferimenti con questi quattro
campi identici. Successivamente viene creato un oggetto della classe
“Modifica_Pubblicazione”, e viene invocato su di esso il metodo “carica_dati”, al
quale viene passato come parametro il valore “ID_Riferimento” ottenuto con la
query appena conclusa. Fatto ciò, viene visualizzato il rispettivo form.
Tutte le eccezioni che possano venire sollevate sono gestite visualizzando i rispettivi
form con i messaggi di errore.

MODIFICA_PUBBLICAZIONE

All’apertura di questo form vengono visualizzati i dati del riferimento per il quale è
stata creata un’istanza di questa classe. I dati vengono visualizzati con il metodo
“carica_dati” all’apertura del form.

28

Il codice del metodo “carica_dati”:
public void carica_dati(int rif)
{
globale_IDrif = rif;
string s=Application.StartupPath+quot;SettingsstringaConnessione.txtquot;;
if (!File.Exists(s))
{
ef.Show();
}
{
string source=tr.ReadLine();
conn.Open(); //apre la connessione
SqlCommand cmd;
string tipoRif;
int numRif=0;
try
{
string dati=quot;SELECT ID_TipoRif, Titolo, Autori, Rivista, Volume, Anno_Pubblicazione, quot; +
quot;Pag_iniz, Pag_fin,quot;+
quot;Riferimento_veloce FROM tblRiferimento WHERE ID_Riferimento=quot;+rif;
cmd = new SqlCommand(dati, conn);
SqlDataReader dati_array = cmd.ExecuteReader();
while(dati_array.Read())
{
numRif= (int)dati_array[0];
this.textBox10.Text=dati_array[1].ToString(); // caricamento delle textbox
this.textBox9.Text = dati_array[2].ToString();
}

dati_array.Close();
}
catch (Exception load_e)
{
this.textBox10.Text = quot;ERRORE: Caricamento non riuscitoquot;;
}
try
{
tipoRif = quot;SELECT RisTAG FROM tblTipoRif WHERE ID_TipoRif=quot; + numRif;
SqlCommand cmd1 = new SqlCommand(tipoRif, conn);
string tipo= (string)cmd1.ExecuteScalar();

29

this.textBox1.Text = tipo;
int[] int_arr = new int[10000000];
int i = 0;
string cognNom=quot;quot;;
string autori_associati_ID = quot;SELECT ID_Personale FROM tblRif_Pers quot; +
quot;WHERE ID_Rif=quot; + rif;
cmd = new SqlCommand(autori_associati_ID, conn);
SqlDataReader autorID_array = cmd.ExecuteReader();
while(autorID_array.Read())
{
int_arr[i] = (int)autorID_array[0];
i++;
}
autorID_array.Close();
for (int j=0;j<i;j++)
{
string autori_associati = quot;SELECT Cognome, Nome FROM tblPersonale quot; +
quot;WHERE ID_Personale=quot;+int_arr[j];
cmd = new SqlCommand(autori_associati, conn);
SqlDataReader autor_array = cmd.ExecuteReader();
while(autor_array.Read())
{
cognNom = autor_array[0].ToString() + quot;,quot; + autor_array[1].ToString();
}
this.listBox1.Items.Add(cognNom); //caricamento listbox con persone
autor_array.Close(); // associate
}}
catch (Exception load_e1)
{
this.listBox1.Items.Add(quot;ERRORE: Caricamentoquot;);
this.listBox1.Items.Add(quot;non riuscitoquot;);
}
try
{
string cogn_Nom = quot;quot;;
string autori_non_associati = quot;SELECT Cognome,Nome FROM tblPersonale quot; +
quot;WHERE ID_Personale NOT IN (SELECT ID_Personale quot; +
quot;FROM tblRif_Pers WHERE ID_Rif=quot; + rif + quot;)quot;;
cmd = new SqlCommand(autori_non_associati, conn);
SqlDataReader autor_non_array = cmd.ExecuteReader();
while (autor_non_array.Read())
{
cogn_Nom = autor_non_array[0].ToString() + quot;,quot; + autor_non_array[1].ToString();
this.listBox2.Items.Add(cogn_Nom); //caricamento listbox con persone
} // non associate
autor_non_array.Close();
}
catch (Exception load_e2) {
this.listBox2.Items.Add(quot;ERRORE: Caricamentoquot;);
this.listBox2.Items.Add(quot;non riuscitoquot;); }
conn.Close();
}}

30

Il metodo “carica_dati”, il quale codice è riportato sopra, carica le textbox con tutti i
dati del riferimento, inoltre riempie una listbox con le persone associate al
medesimo riferimento, mentre ne riempie una analoga con le persone non
associate.
È possibile effettuare direttamente qualsiasi modifica sui dati delle textbox. Questo
non è possibile solamente a quella affianco alla label “Tipo Riferimento” in quanto
non ritenuto opportuno permettere tale modifica.
È possibile associare o dissociare le persone dal riferimento in questione. Questa
operazione viene eseguita spostando le persone tra le due listbox per mezzo di due
bottoni con le frecce che indicano il verso dello spostamento della persona o
persone selezionate nelle listbox.
Infine, le modifiche vengono salvate nel database premendo il bottone “Salva
Modifiche”. Alla sua pressione viene aperta la connessione col database e viene
eseguita la query di update del record il quale campo “ID_Riferimento” corrisponde
a quello passato al metodo “carica_dati”. Vengono aggiornati tutti i campi di questo
record, tranne “ID_TipoRif”. Esso identifica il tipo di riferimento, e come detto
sopra, la textbox corrispondente non era modificabile.
Fatto questo, vengono associate/dissociate le persone al/dal riferimento.
Infine, se tutto è andato a buon fine, viene visualizzata la finestra
“Salvataggio_modifiche_OK” che informa l’utente che le modifiche sono state fatte.
Allo stesso momento viene aggiornata la riga della listbox nella finestra
“Amministrazione”. Persino la riga relativa viene cancellata se il riferimento è stato
dissociato dalla persona corrente.
Il codice che sta dietro il click sul bottone “Salva Modifiche” viene riportato qui:

private void button3_Click(object sender, EventArgs e)
{
string s=Application.StartupPath+quot;SettingsstringaConnessione.txtquot;;
if (!File.Exists(s))
{
ef.Show();
}
{
try
{
string source=tr.ReadLine();
conn.Open(); //apre la connessione
SqlCommand cmd;

31

string stringa=quot;UPDATE tblRiferimento SET Titolo='quot;+this.textBox10.Text+
quot; ', Autori='quot;+this.textBox9.Text+quot;', Rivista='quot;+this.textBox8.Text+quot;' quot;;
if (this.textBox4.Text!=quot;quot;)
stringa = stringa + quot;, Volume='quot; + this.textBox4.Text + quot;'quot;;
else stringa = stringa + quot;, Volume= nullquot;;
stringa = stringa + quot;, Anno_Pubblicazione=quot; + this.textBox7.Text;
else stringa = stringa + quot;, Anno_Pubblicazione= nullquot;;
stringa = stringa + quot;, Pag_iniz=quot; + this.textBox2.Text;
else stringa = stringa + quot;, Pag_iniz= nullquot;;
stringa = stringa + quot;, Pag_fin=quot; + this.textBox5.Text;
else stringa = stringa + quot;, Pag_fin= nullquot;;
stringa = stringa + quot;, Riferimento_veloce='quot; + this.textBox3.Text + quot;'quot;;
else stringa = stringa + quot;, Riferimento_veloce= nullquot;;
stringa=stringa+quot; WHERE ID_Riferimento=quot; + globale_IDrif;
cmd = new SqlCommand(stringa, conn);
cmd.ExecuteNonQuery(); // esegue la query update del riferimento
int num_elementi= this.listBox1.Items.Count;
System.Windows.Forms.ListBox.ObjectCollection oc = this.listBox1.Items;
int count = oc.Count;
Object[] ob_c = new Object[count];
oc.CopyTo(ob_c, 0);
for (int i=0;i<num_elementi;i++)
{
char[] spazio = new char[1]; ;
spazio[0] = ',';
String[] str_cogn_nom = this.listBox1.GetItemText(ob_c[i]).Split(spazio[0]);
string aut_ID= quot;SELECT ID_Personale FROM tblPersonale WHERE Cognome = ' quot; +
str_cogn_nom[0]+ quot; ' AND Nome=' quot;+str_cogn_nom[1]+quot; ' quot;;
cmd = new SqlCommand(aut_ID, conn);
int autore_ID = (int)cmd.ExecuteScalar();
try
{
string autori_ass=quot;INSERT INTO tblRif_Pers(ID_Rif, ID_Personale) VALUES(quot;+
globale_IDrif+quot;,quot;+autore_ID+quot;)quot;;
cmd = new SqlCommand(autori_ass, conn); // cerca di associare tutte le
cmd.ExecuteNonQuery(); //persone della listbox, anche quelle già associate
}
catch(SqlException prim_e) // acchiappa l’eccezione che viene sollevata quando cerca
// { // di associare una persona già associata, e la gestisce non facendo niente,
// il che corrisponde al passare alla prossima persona da associare
}
}
int num_elementi1= this.listBox2.Items.Count;
System.Windows.Forms.ListBox.ObjectCollection oc1 = this.listBox2.Items;
int count1 = oc1.Count;
Object[] ob_c1 = new Object[count1];

32

oc1.CopyTo(ob_c1, 0);
for (int i=0;i<num_elementi1;i++)
{
char[] spazio1 = new char[1]; ;
spazio1[0] = ',';
String[] str_cogn_nom1 = this.listBox2.GetItemText(ob_c1[i]).Split(spazio1[0]);
string aut_ID1=quot;SELECT ID_Personale FROM tblPersonale WHERE Cognome = ' quot; +
str_cogn_nom1[0]+ quot; ' AND Nome=' quot; + str_cogn_nom1[1] + quot; ' quot;;
cmd = new SqlCommand(aut_ID1, conn);
int autore_ID1 = (int)cmd.ExecuteScalar();
string canc_aut = quot;DELETE FROM tblRif_Pers WHERE ID_Rif=quot; + globale_IDrif +
quot; AND ID_Personale=quot; + autore_ID1;
cmd = new SqlCommand(canc_aut, conn); //cancella dalla tabella “tblRif_Pers”
cmd.ExecuteNonQuery(); // il record che associa la determinata persona al riferimento
}

conn.Close();
this.Close();
Salvataggio_modifiche_OK sa_ok = new Salvataggio_modifiche_OK();
sa_ok.Show();
amm_interno.mostra_riferimenti_dell_autore(); //refresh della listbox nel
} // form “Amministrazione”

catch(Exception load_e4)
{
Errore_Amministrazione eam = new Errore_Amministrazione();
eam.Show();
}
}
}

Finisce qui la parte che descrive l’implementazione dei singoli moduli.

33

DIAGRAMMA DI FLUSSO

Diagramma di flusso finale:

“Esci”
FINE

“Amministrazione” “Importazione”
PRINCIPALE

“Esci” “Annulla”
ERRORE_FILE
“Cancella
pubblicazione”

CANCELLAZIONE “Sfoglia”
IMPORTAZIONE
AMMINISTRAZIONE

ERRORE_AMMINISTRAZIONE
“Modifica
pubblicazione” “Apri”
CERCA
ERRORE_CAN ERRORE_APERTURA_FILE_
“Chiudi”
CELLAZIONE CONNESSIONE

“Annulla”

RIFERIMENTI
ERRORE_FILE

MODIFICA
Doppio click
listbox
ERRORE_APERTURA_FILE_
CONNESSIONE “Annulla”
“Salva
Modifiche”
ERRORE_APERTURA_FILE_
CONNESSIONE DETTAGLI
ERRORE_
AMMINISTRAZIO
NE ERRORE_IMPORTAZIONE
“Importa”

“OK”
“OK”
SALVATAGGIO_MODIFICHE_ IMPORTAZIONE_
OK RIUSCITA

34

3.1.2 Interfaccia

Per spiegare come l’utente si interfaccia col sistema, bisogna prima descrivere la
installazione e configurazione necessaria del sistema sulla macchina dell’utente, e
poi fare un esempio d’uso che dovrebbe togliere ogni dubbio sulla modalità
d’utilizzo.

3.1.2.1 Installazione e configurazione

INSTALLAZIONE

• Per potere usufruire di questo sistema in modalità off-line bisogna avere sul
proprio PC la banca dati (pubblicazioni.mdf e pubblicazioni_log.ldf), l’applicativo
(Tesi_schermata1.exe) e la cartella di nome “Settings” che si deve trovare nello
stesso directory dell’applicativo, e deve contenere al suo interno un file di nome
“stringaConnessione.txt”, il quale contiene, appunto, la stringa di connessione al
database. Sul contenuto di questo file parleremo di più nel paragrafo
“Configurazione”. Inoltre bisogna avere installato il SQL Server ed il Microsoft .NET
Framework.

35

Passi da compiere per collegare la banca dati al server locale:

1. Connettersi al server locale

2. Click col tasto destro sulla cartella “Databases” nella finestra “Object
Explorer” e poi click su “Attach”

36

3. Nella finestra che si apre cliccare il bottone “Add”, successivamente scegliere
il file “pubblicazioni.mdf” dalla cartella dove è stato salvato, ed infine cliccare
“OK”.

Fatto ciò, il nostro database risulta collegato al server locale.

37

Possiamo accertarci di questo avvenimento vedendolo nella cartella “Databases”
nella finestra “Object Explorer”.

• Utilizzare il sistema invece nella modalità on-line, ovvero quando la banca dati
si trova su un’altra macchina della rete, è il caso di utilizzo decisamente più
probabile. Per fare ciò, bisogna avere sul proprio PC l’applicativo
(Tesi_schermata1.exe) e la cartella di nome “Settings” che si deve trovare, anche in
questo caso, nello stesso directory dell’applicativo, e deve contenere al suo interno
un file di nome “stringaConnessione.txt”. Inoltre il PC deve essere dotato del
Microsoft .NET Framework.
In questa modalità non c’è, appunto, il bisogno di collegare il database al server
locale. Però, in ogni caso, il database deve essere collegato al server locale della
macchina sulla quale si trova.

38

CONFIGURAZIONE

Il sistema per funzionare deve essere configurato opportunamente. La
configurazione consiste nel modificare una parte della stringa di connessione, in
modo che si riferisca al server sul quale si trova il database. Quindi andiamo ad
aprire il file “stringaConnessione.txt”, che si trova nella cartella “Settings”, la quale si
deve trovare nella cartella contenente l’eseguibile dell’ applicativo.

• Se vogliamo utilizzare il sistema in modalità off-line, bisogna cambiare il valore
del “Data Source”, inserendo il nome del server locale. Non c’è bisogno di
modificare niente altro. Una volta modificato, il file viene ovviamente salvato.

Esempio:

Data Source=PC-MAJA; Initial Catalog=pubblicazioni; Integrated Security=True

Inserire qui il nome del server locale

• Se invece si desidera utilizzare il sistema in modalità on-line, anche in questo
caso si deve cambiare la stringa di connessione. In questo caso al posto del server
locale si deve inserire il nome del server remoto sul quale si trova il database.

3.1.2.2 Esempio d’uso

Facendo partire il programma applicativo (Tesi_schermata1.exe), viene visualizzata
questa finestra:

39

Se vogliamo importare dei riferimenti da un file RIS che abbiamo da qualsiasi parte
nel nostro PC, schiacciamo il bottone “Importazione”. Questa operazione ci apre la
seguente finestra:

Qui abbiamo la possibilità di scrivere direttamente il nome del file (attenzione: con il
path completo!), oppure aprire la finestra la quale ci permette di sfogliare le cartelle
del PC e scegliere il file RIS desiderato. Non si ritiene necessario accompagnare
questo procedimento con le immagini del programma.
Una volta selezionato il file, il suo nome appare al posto della scritta “*.ris”.

40

Successivamente premendo il bottone apri viene visualizzata la finestra
“Riferimenti”, la quale ci mostra i possibili riferimenti da importare. Per motivi di
questo esempio abbiamo utilizzato un file RIS che ci ha portato alla seguente
schermata:

41

Adesso scegliamo il riferimento che vorremmo importare, e facciamo il doppio click
sopra. Questo ci fa aprire la prossima finestra, quella dove possiamo modificare i
dati ed associare il riferimento alle persone:

42

Se adesso decidiamo di associare questo riferimento ad esempio a Fermeglia
Maurizio e Ferrone Marco, dobbiamo selezionare i loro nomi e schiacciare il bottone
con la freccia che punta verso sinistra. Nel caso cambiassimo idea dopo e non
volgiamo più associarla a qualcuno dei due, selezioniamo la persona desiderata, e
schiacciamo il bottone della freccia che punta verso destra.

Esempio:

43

Quando abbiamo terminato con tutte le modifiche ed associazioni, e volgiamo
importare il riferimento, clicchiamo il bottone “Importa”, il quale ci mostra la
finestra che ci informa che l’importazione è andata a buon fine, ed inoltre ci toglie il
riferimento appena importato dalla finestra “Riferimenti”. Nel caso di importazione
non riuscita viene visualizzata la finestra di errore, e la modifica alla finestra
“Riferimenti” non avviene. Supponiamo che l’importazione sia andata a buon fine.
Vediamo quindi questa finestra:

Adesso possiamo selezionare il prossimo riferimento da importare nella finestra
“Riferimenti” e ripetere il medesimo procedimento finché non abbiamo importato
tutti i riferimenti che volevamo.
Quando abbiamo terminato, premiamo il bottone “Chiudi” della finestra
“Riferimenti”. Questo ci riporta sul menù di partenza.

44

Se volgiamo amministrare i riferimenti che sono contenuti nel database, premiamo il
bottone “Amministrazione” del menù di partenza, ovvero dalla finestra
“Pubblicazioni”. Facendo così si apre la finestra “Amministrazione” dove possiamo
scegliere dalla combo box la persona della quale vogliamo amministrare i
riferimenti. Cliccando il bottone “Mostra” ci vengono visualizzati i riferimenti ed il
gruppo di appartenenza della persona. Prendiamo come esempio Fermeglia
Maurizio. Dopo aver cliccato “Mostra” vediamo la seguente schermata:

45

Ora se vogliamo cancellare un riferimento, lo selezioniamo e premiamo il bottone
“Cancella pubblicazione”. Questo fa si che il riferimento viene cancellato dal
database e pure da questa schermata. Non è possibile selezionare più riferimenti
nello stesso momento. Tutte le operazioni si fanno su uno alla volta.

Se vogliamo modificare un riferimento, lo selezioniamo e clicchiamo il bottone
“Modifica pubblicazione”. Questo ci apre la seguente finestra, di nome “Modifica”:

Qui possiamo modificare i dati della pubblicazione, ed associare oppure dissociare il
riferimento dalla determinata persona, attraverso le due listbox e i due bottoni che
sono auto esplicativi.
Quando abbiamo terminato le modifiche, premendo il bottone “Salva Modifiche”,
tutte le modifiche vengono salvate. Viene visualizzata la finestra che ci informa
dell’avvenuto, e successivamente viene aggiornata la finestra “Amministrazione”.
Se abbiamo finito con tutto, premiamo il bottone “Esci”, che ci chiude la finestra
“Amministrazione” e ci lascia a quella “Pubblicazioni”.
Se vogliamo terminare tutto il programma, premiamo il bottone “Esci”, ed anche
l’ultima finestra viene chiusa e tutte le risorse che utilizzava rilasciate.

46

3.2 Test

Durante, ed al termine della realizzazione del sistema, sono stati eseguiti dei test
funzionali sul programma e sui moduli per assicurarsi del loro corretto
funzionamento. Questi test comprendevano sia i dati “a caso”, sia i dati “critici”
dove mancavano informazioni, per poter gestire nel modo migliore le eccezioni.
Questi test sono stati eseguiti sul PC che è stato utilizzato per lo sviluppo del
sistema. Una volta accertati che tutto funziona bene ed assicurati che gli obiettivi
iniziali sono stati raggiunti, il sistema è stato portato al committente per la
validazione. Dopo la conferma del committente, il sistema è stato installato sul suo
PC, ovvero, su uno dei ambienti finali, di nuovo accertandosi che il tutto funziona
correttamente.

47

4 CONCLUSIONI

Questo capitolo porta alcune considerazioni finali sul lavoro svolto. Si valuterà
se gli obbiettivi iniziali sono stati raggiunti. Si cercherà in qualche modo di
quantificare il lavoro svolto. Si rappresenterà lo stato attuale del sistema, l’utilizzo
corrente, e l’utilizzo che gli si prospetta in un futuro prossimo. Infine, il capitolo si
concluderà esprimendo alcune considerazioni riguardanti il livello di soddisfazione
personale dovuto al lavoro effettuato.

4.1 Obiettivi

Girandosi indietro cercando di confrontare il lavoro ottenuto con il lavoro
assegnato si può concludere che tutti gli obiettivi prestabiliti sono stati raggiunti. Il
fatto che il sistema è stato portato al committente, il relatore di questa tesi, il quale
è nello stesso tempo anche un utente finale, per la validazione dei requisiti, ed è
stato giudicato valido, non fa altro che rafforzare la suddetta affermazione.

4.2 Lavoro svolto

In questo paragrafo cercherò di quantificare il lavoro svolto attraverso il
numero delle classi dell’applicativo, ed il numero di tabelle del database sviluppato.

Numero delle classi del programma applicativo: 13

Numero di tabelle del database: 5

4.3 Stato attuale

Attualmente il programma è, come già detto sopra stato consegnato al
committente, nonché utente. Come già detto nella descrizione del progetto, esso è
stato creato per una condivisione di dati in rete, e la loro visualizzazione in Internet,
sul sito http://www.dicamp.units.it/Research/Publications/default.aspx . I dati
verranno visualizzati in maniera analoga a quella della visualizzazione delle
pubblicazioni sul sito http://www.mose.units.it/ .

48

Non mi risulta che il sistema sia già operativo sul sito citato sopra, ma lo dovrebbe
essere in un futuro prossimo.

4.4 Considerazioni personali

Personalmente mi ritengo soddisfatta del lavoro svolto. È stata una bella
esperienza. Ho imparato tante cose, quindi è stato utile. Le ore volavano tra gli alti e
bassi, tra le arrabbiature e congratulazioni con me stessa. Devo ammettere che mi è
dispiaciuto un po’ quando l’ho finito. Ma soprattutto sono rimasta parecchio
sorpresa del modo in cui mi ha preso. Non me l’aspettavo.
Come ultima cosa devo fare presente che senza il mio relatore questa
esperienza sarebbe stata molto meno bella e motivante.

50

5 BIBLIOGRAFIA

• “C# - Guida per lo sviluppatore” - Robinson, Cornes, Glynn, Harvey, McQueen,
Moemeka, Nagel, Skinner, Watson
- Ulrico Hoepli Editori S.p.A. 2001
- Ristampa n. 4, anno 2005

• “Introduzione a Microsoft SQL Server 2005 per sviluppatori” - DeBetta
- Mondadori
Informatica
- Edizione n. 1, anno
2005
• http://msdn.microsoft.com/it-it/library/kx37x362.aspx

• http://msdn.microsoft.com/it-it/library/ms310242.aspx

• http://www.vbsimple.net/index.htm?/database/db_08_06.htm

51

Relazione Agic

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (6)

Ähnlich wie Relazione Agic

Ähnlich wie Relazione Agic (20)

Relazione Agic