Università degli Studi di Trieste

Facoltà di Ingegneria

Corso di Laurea Triennale di Ingegneria Informatica

TESI DI LAUREA TRIENNALE IN “SISTEMI INFORMATIVI”

SVILUPPO DI UNA APPLICAZIONE PER L’ACQUISIZIONE DI DATI DA SUPPORTO

CARTACEO: CASO DEI CURRICULUM VITAE

Relatore:Prof. Fermeglia Maurizio

Laureando:Faelli Roberto

Anno Accademico 2008/2009

Sommario

1 - INTRODUZIONE...........................................................................................................................32 – ANALISI........................................................................................................................................5

2.1 – Analisi del sistema...................................................................................................................62.1.1 – Il progetto.........................................................................................................................62.1.2 – Utenza...............................................................................................................................62.1.3 – L’ambiente di sviluppo.....................................................................................................72.1.4 – Definizione dei requisiti...................................................................................................7

2.2 – Progettazione del sistema........................................................................................................92.2.1 – L’architettura....................................................................................................................92.2.2 – Use Case Diagram..........................................................................................................112.2.4 – Activity diagram.............................................................................................................122.2.5 – Class diagram.................................................................................................................13

3 - REALIZZAZIONE.......................................................................................................................153.1 Implementazione......................................................................................................................16

3.1.1 Visual Studio.....................................................................................................................163.1.2 Le novità del .NET Framework 3.5...................................................................................173.1.3 Linguaggio Visual C#.......................................................................................................183.1.4 XPS (XML Paper Specification).......................................................................................193.1.5 Interfaccia grafica..............................................................................................................213.1.6 Esempio di utilizzo............................................................................................................23

2

1 - INTRODUZIONE

In questa tesi si vuole descrivere la progettazione e lo sviluppo di una applicazione che

permetta di acquisire dati da supporto cartaceo ed in particolare si concentra

sull’acquisizione dei dati relativi ai curriculum vitae in formato Europeo.

Lo scopo del progetto, in sintesi, è quello di creare un applicativo che, permetta di effettuare

la scansione di un curriculum vitae esistente (tipicamente in formato PDF oppure DOC)

convertirlo nel formato XPS, effettuare un mappaggio dei valori letti durante la scansione in

una opportuna struttura ed esplicitare i parametri che permettono di migliorare la qualità

dell’interpretazione.

Uno degli obiettivi fondamentali che il laureando si è posto è stato quello di creare

un’applicazione che risulti essere il più possibile “user-friendly” ma nello stesso tempo

completa di tutte le funzionalità (modelli di acquisizione, parametri definibili dall’utente,

anteprima del documento, acquisizione da più fonti…) necessarie a questo tipo di lavoro.

Per realizzare l’applicazione è stato utilizzato il linguaggio di programmazione C#

all’interno dell’ambiente di sviluppo Visual Studio 2008 Professional.

Le fasi principali che hanno portato allo sviluppo del programma si possono riassumere

brevemente nei seguenti punti:

Analisi delle esigenze da risolvere;

Valutazione delle tecnologie disponibili;

Studio di realtà già esistenti;

Raccolta dei requisiti per la progettazione dell’applicazione;

Progettazione architetturale;

Implementazione e realizzazione dell’applicazione;

Test del prototipo;

La seguente tesi si suddivide in due sezioni principali.

3

Nella prima parte verrà illustrata l’analisi e la progettazione del sistema da realizzare. In

particolare saranno esposte alcune considerazioni sui documenti di tipo XPS (di cui

parleremo approfonditamente nelle prossime pagine)

Si procederà poi con la raccolta delle informazioni, con la stesura dei requisiti ed infine si

passerà alla progettazione vera e propria attraverso i diagrammi UML.

Nella seconda parte verrà trattata la realizzazione del programma. Si inizierà con una

descrizione dettagliata della sua implementazione mediante il linguaggio C# e si passerà poi

ad una illustrazione del suo funzionamento.

La tesi termina con un sezione dedicata alle conclusioni in cui si riassume lo stato attuale del

progetto: descrive in particolare cosa, per ora, è stato fatto e cosa c’è ancora da fare per

rendere il prodotto più completo e funzionale.

4

2 – ANALISI

In questa prima parte del documento viene presentata un’analisi del sistema che si andrà a

realizzare. Si inizierà da un resoconto di quelle che sono le necessità che l’applicativo

dovrà risolvere, per arrivare poi alla individuazione dei requisiti del sistema. Una volta

determinati tali requisiti si passerà alla stesura della progettazione, nella quale verranno

illustrati l’architettura di riferimento e alcuni diagrammi UML.

5

2.1 – Analisi del sistema

2.1.1 – Il progetto

Come già anticipato nell’introduzione, il progetto richiede la costruzione di una

applicazione Windows Form che permetta l’acquisizione di curriculum vitae (di seguito CV)

pervenuti in formato cartaceo oppure mediante posta elettronica.

Nel caso in cui il CV sia in formato cartaceo, l’utente effettuerà la scansione del documento

per poi salvarlo in una opportuna cartella. In seguito si procederà alla ricostruzione del CV

(in una apposita struttura) grazie alle funzionalità presenti nel programma.

Nel caso il CV pervenga mediante posta elettronica, il programma offrirà all’utente la

possibilità di accedere ai messaggi presenti nella mailbox e di ricostruire l’eventuale CV

allegato (come nel caso precedente).

Ad acquisizione completata, il CV sarà disponibile nel nuovo formato XML (eXtensible

Markup Language) per ulteriori utilizzi futuri (da definire con l’utente finale in quanto

dipende dal gestionale utilizzato…).

2.1.2 – Utenza

L’utilizzo del programma non implica alcuna difficoltà per cui può essere utilizzato anche

da persone che presentano conoscenze elementari di informatica (concetto di file,

cartella…). In una prima fase, si dovrà semplicemente informare il software quale sarà la

cartella contenente i CV da acquisire. I parametri di acquisizione sono già ottimizzati per il

CV in formato Europeo. L’operatore può comunque in ogni istante variare tali parametri e

verificarne in tempo reale l’efficacia. Se le modifiche sono soddisfacenti, è possibile

salvarle e utilizzarle successivamente. Al momento, il programma salva il CV nella stessa

cartella di origine (nulla vieta che in una prossima release venga chiesto all’operatore in

quale altro percorso salvare…).

6

2.1.3 – L’ambiente di sviluppo

Per sviluppare l’applicazione è stato utilizzato L’IDE Microsoft Visual Studio 2008 e il

linguaggio di programmazione C# (C Sharp).

In particolare, all’interno del programma, si sono utilizzati i namespaces

System.Windows.Xps al fine di mettere a disposizione delle classi in grado di

leggere/scrivere documenti XPS nonché i namespaces System.Xml per fornire supporto

all'elaborazione dei files XML.

Da quanto detto, è evidente che i curriculum vitae prima di essere manipolati dal

programma, devono essere prima di tutto trasformati da supporto cartaceo a supporto

digitale ed in particolare devono essere convertiti in formato XPS. Il programma, infatti,

permette di convertire formati di CV diversi (ad esempio .DOC, .PDF, .RTF) in formato

XPS grazie all’OCR engine della OmniPage (API – Application Program Interface messe a

disposizione del programmatore).

2.1.4 – Definizione dei requisiti

A seguito delle considerazioni fatte nei paragrafi precedenti, è possibile stendere un elenco dei requisiti a cui il software dovrà far fronte.

Requisiti funzionali:

Source selector:

l’applicazione deve poter acquisire documenti (CV) da più sorgenti distinte. Nel caso

specifico, sono state individuate due sorgenti:

Cartella presente nel file system (definibile all’interno del programma)

Casella di posta (i messaggi che contengono allegati…)

Source content:

all’interno dell’applicazione deve essere presente un listato all’interno del quale l’utente

potrà trovare tutti i files dei CV da convertire

Selected document:

l’utente deve essere in grado di effettuare una anteprima del CV originale prima di

procedere alla conversione

7

Scan current:

il software deve essere in grado di acquisire CV con formati diversi ad

esempio .DOC, .RTF, .XPS e quindi effettuarne il parsing in una nuova struttura di tipo XPS

View scan result:

l’utente deve essere in grado di visualizzare il CV ricostruito in una apposita finestra

Action panel:

L’utente deve essere in grado di correggere i parametri relativi alla scansione e quindi di

ritentare l’operazione (salvando eventualmente i parametri modificati)

L’applicazione, al termine dell’acquisizione, deve salvare il nuovo CV in formato .XML

Edit parameters:

Tutti i parametri contenuti nell’applicativo devono essere facilmente modificabili e salvati in

modo persistente su file.

8

2.2 – Progettazione del sistema

2.2.1 – L’architettura

L’architettura di un prodotto software rappresenta il modo con cui vengono organizzate ed interfacciate le varie componenti che andranno a formare il sistema finale.

Nel caso del programma realizzato, ci troviamo nella programmazione di Windows Forms mediante linguaggio C#.

Lo schema che meglio rappresenta l’architettura del software è presente in figura 1. Si tratta dell'architettura .NET Framework. Nei prossimi paragrafi andremo ad analizzare i vari strati che compongono tale framework.

Figura 1 – architettura .NET Framework

Common Language Specification (CLS)

Il CLS è una serie di regole che si applicano per generare gli assembly. Se un componente scritto in un linguaggio (ad esempio C#) dovrà essere utilizzato da un altro linguaggio (ad esempio VB.NET), allora chi scrive il componente dovrà aderire ai tipi e alle strutture definite dal CLS.

Ad esempio, il tipo Int32 è compatibile con il CLS ed i linguaggi e gli strumenti possono aspettarsi che altri linguaggi e strumenti conformi al CLS sappiano come utilizzarlo correttamente.

9

Una libreria costituita da codice aderente al CLS è chiamata "CLS Framework". Queste librerie sono progettate per essere utilizzate da un gran numero di linguaggi e strumenti di sviluppo.

Windows Forms

Microsoft Windows Forms è il nome dato alla parte di GUI (Graphical User Interface) del framework Microsoft .NET.Microsoft Windows Forms è visto come un sostituto per il precedente e più complesso sistema Microsoft Foundation Classes basato su C++.

.NET Framework Base Classes

Le classi del .NET Framework costituiscono un insieme di librerie di classe (API) unificato, orientato all'oggetto, gerarchico ed estensibile che gli sviluppatori possono utilizzare dai linguaggi che già conoscono.Attualmente, chi programma in Visual C++ utilizza le Microsoft Foundation Classes, gli sviluppatori Visual J++ adoperano le Windows Foundation Classes, mentre coloro che scrivono in Visual Basic sfruttano il runtime di Visual Basic stesso. In poche parole, le classi del .NET Framework unificano questi approcci differenti, dando vita ad un sovrainsieme di tutte le varie funzionalità. Di conseguenza, non è più necessario conoscere diversi modelli ad oggetti o librerie di classe. Creando un unico insieme di API comune a tutti i linguaggi di programmazione, il .NET Framework consente l'ereditarietà, la gestione degli errori ed il debug tra linguaggi. In altre parole, tutti i linguaggi di programmazione, da JScript a C++, diventano uguali, e gli sviluppatori sono liberi di scegliere quello più adatto alle proprie necessità.Il .NET Framework fornisce classi che possono essere invocate da qualsiasi linguaggio di programmazione. Tali classi si conformano ad un insieme di criteri di nomenclatura e di progettazione che riducono ulteriormente la curva di apprendimento degli sviluppatori.

Common Language Runtime (CLR)

Il Common Language Runtime rappresenta un motore di esecuzione ad elevate prestazioni. Il codice cui il runtime si riferisce e la cui esecuzione è gestita da esso viene detto codice gestito (managed code). La responsabilità per attività quali la creazione di oggetti, l'esecuzione di chiamate a metodi e così via, è demandata al Common Language Runtime che consente di fornire servizi aggiuntivi al codice in esecuzione.A dispetto del suo nome, il Common Language Runtime riveste in realtà un ruolo tanto nella fase di sviluppo di componenti quanto nella fase di esecuzione.

Mentre la componente è in esecuzione, il runtime fornisce servizi quali la gestione della memoria (inclusa la garbage collection), la gestione di processi e thread, il potenziamento della sicurezza e si preoccupa di soddisfare le eventuali dipendenze da altre componenti.

Durante la fase di sviluppo, il ruolo del runtime cambia leggermente. Grazie agli automatismi introdotti (ad esempio nella gestione della memoria), il runtime rende la vita dello sviluppatore molto più semplice. In particolare, caratteristiche quali la gestione del ciclo di vita, una nomenclatura forte dei tipi, la gestione delle eccezioni tra linguaggi, la gestione degli eventi basati sui delegate, il binding dinamico e la reflection, riducono considerevolmente la quantità di codice che occorre scrivere per realizzare codice a componenti riutilizzabili.

10

I runtime non rappresentano una novità per i linguaggi: molti linguaggi di programmazione possiedono un runtime. Visual Basic, ad esempio, possiede forse il runtime più famoso (il VBRUN), ma anche Visual C++ ne possiede uno (MSVCRT) e così pure Visual FoxPro, Jscript, SmallTalk, Perl, Python, Haskell e Java. Il ruolo critico del Common Language Runtime, e ciò che realmente lo contraddistingue, è il fatto che fornisce un ambiente di runtime unificato comune a tutti i linguaggi di programmazione.Le caratteristiche fondamentali del runtime includono un sistema comune di tipi che consente l'integrazione tra linguaggi (oggetti C# possono ereditare classi C++, ad esempio) , componenti autodescrittive, un deployment più semplice ed un miglior controllo dei conflitti di versione ed infine, servizi di sicurezza integrati.

2.2.2 – Use Case Diagram

Dall’elenco dei requisiti illustrati nel paragrafo 2.1.4 è possibile ricavare direttamente i casi d’uso dell’applicazione. Di seguito viene visualizzato il diagramma dei casi d’uso, il quale permette allo sviluppatore di avere una visione d’insieme del sistema che si stà analizzando.

Figura 2 – Use Case diagram

11

L’attore del sistema è unico e coincide con l’utente finale che svolge le funzioni di caricamento e conversione dei CV.

2.2.4 – Activity diagram

L’activity diagram riportato in Figura 3 mostra la sequenza di operazioni che devono essere effettuate al fine di convertire un CV dal formato originale (ad es. PDF) verso il nuovo formato XML.

Figura 3 – Activity diagram

12

2.2.5 – Class diagram

Il diagramma delle classi descrive il sistema generale, la sua struttura statica, ovvero la sua modellizzazione in classi. È composto dai seguenti elementi:

Classi

Una classe è caratterizzata da un nome e descrive le proprietà comuni ad un gruppo di oggetti. Una classe può essere completata con la lista di attributi e operazioni che contiene.È un rettangolo composto da tre parti: il nome della classe in grassetto, la lista di attributi e la lista di operazioni. Il nome della classe è obbligatorio mentre le due parti sottostanti possono essere tralasciate.

Attributi

Un attributo è un elemento della classe che contiene un valore. L'attributo deve essere unico solo nella classe, quindi due classi possono avere attributi identificati dallo stesso nome. Un attributo può contenere un valore costante oppure può essere modificato da delle operazioni. Un attributo può contenere solo dei valori e non degli oggetti: esso rappresenta infatti una proprietà dell'entità reale. Esso non dovrebbe essere un identificatore univoco creato per distinguere due istanze. Se l'attributo rappresenta un identificatore reale, quale ad esempio il codice fiscale, esso può essere utilizzato anche per distinguere due oggetti.

Operazioni

Un'operazione è un'azione o una trasformazione che può essere applicata da o su un oggetto in una classe. Tutti gli oggetti di una classe condividono le stesse operazioni.Argomenti impliciti di un'operazione sono l'oggetto su cui si applica che è l'oggetto stesso e l'azione effettuata, che può dipendere dalla particolare implementazione. Gli argomenti espliciti sono opzionali e devono avere un tipo. Essi sono indicati in una lista separati da virgole. Un'operazione ha un tipo di ritorno, che è opzionale nel caso in cui l'operazione non ritorni alcun valore.

13

Figura 4 - Class Diagram

14

3 - REALIZZAZIONE

In questa seconda unità del documento viene presentata la fase di implementazione della Windows-Application. Si partirà da una breve illustrazione delle particolari caratteristiche dell’ambiente di sviluppo seguita da un tutorial sull’utilizzo del programma.Il capitolo quindi termina proponendo alcuni spezzoni di codice C# che costituiscono l’ossatura del software in oggetto..

15

3.1 Implementazione

3.1.1 Visual Studio

L’intero applicativo è stato sviluppato all’interno dell’ambiente Visual Studio 2008 edizione Professional.

Visual Studio 2008 e il .NET Framework 3.5 aggiungono tante nuove caratteristiche ad un ambiente di lavoro già molto ricco ed avanzato, con l’obiettivo di incrementare ulteriormente i livelli di produttività degli sviluppatori.

Una delle più apprezzate caratteristiche del nuovo Visual Studio è la possibilità di selezionare la versione del .NET Framework con cui lavorare: molto spesso, infatti, capita di dover intervenire su applicazioni sviluppate con versioni diverse del .NET Framework e sarebbe piuttosto scomodo dover installare sulla propria macchina diverse versioni di Visual Studio. Per tale motivo Visual Studio 2008 consente di scegliere quale versione del Framework utilizzare di volta in volta.Scegliendo la versione appropriata del Framework vengono impostati automaticamente i toolbox, i tipi di progetto, i riferimenti e tutto il resto.

Figura 5 – scelta versione framework

16

Si può anche decidere di convertire un’applicazione in una versione differente del .NET Framework.

Se si utilizza Visual Studio 2008 per aprire un’applicazione sviluppata con una versione precedente del Framework viene automaticamente proposto l’aggiornamento della stessa all’ultima versione disponibile, per consentirvi di utilizzare le nuove caratteristiche dell’ambiente e continuare ad utilizzare applicazioni sviluppate con una versione precedente del .NET Framework.

Come per l’edizione 2005, esistono diverse versioni di Visual Studio 2008, ciascuna mirata a ben precise esigenze.

Express Edition - Questa versione è gratuita, liberamente scaricabile e rivolta a coloro che si avvicinano per la prima volta a questo mondo, a chi lo fa per hobby, agli studenti, a tutti coloro che vogliono scrivere codice liberamente e senza particolari pretese. Questa è la risposta di Microsoft agli strumenti freeware disponibili oggi per gli sviluppatori. Chiaramente questa edizione non presenta tutte le funzionalità delle corrispondenti versioni a pagamento, tuttavia contiene tutti gli strumenti necessari e sufficienti per creare applicazioni client/server, siti web e web service.

Standard Edition - Questa versione rappresenta la base di partenza per gli sviluppatori professionisti. Essa è simile alla Express ma mette a disposizione degli sviluppatori tutti i linguaggi .NET ed un insieme maggiore di caratteristiche e funzionalità tra cui: supporto alle soluzioni multiprogetto, Windows Communication Foundation (WCF), Windows Workflow (WF), tool di distribuzione Click-Once, SQL Server 2005 Express incluso, compatibilità con Visual Source Safe e molto altro.

Professional Edition - La differenza fondamentale tra la versione Standard e la Professional è l’insieme più esteso di caratteristiche e funzionalità che la seconda possiede rispetto alla prima. Tra di esse bisogna citare: Visual Studio Tools per Office, SQL Server 2005 Developer Edition, possibilità di sviluppare software per dispositivi mobili, Crystal Reports, Server Explorer e molto altro. Oltre a queste caratteristiche addizionali la versione Professional viene venduta insieme a diverse sottoscrizioni MSDN. Può essere acquistata senza MSDN o con due diverse versioni di MSDN (Professional o Premium). Con la versione MSDN Professional si acquisisce il diritto di utilizzare le vecchie versioni di Visual Studio e di utilizzare Visual Source Safe. Si ottengono anche licenze di Windows, Windows Server, Virtual PC e altre. Con la versione MSDN Premium, oltre a ciò che è stato elencato in precedenza, si ottengono licenze per SQL Server, licenze per Microsoft Office Systems 2007 e altre.

3.1.2 Le novità del .NET Framework 3.5

Il .NET Framework 2.0 ha introdotto diverse classi base, interfacce, generics e altro. Il .NET Framework 3.0 ha introdotto elementi come Windows Presentation Foundation (WPF), Windows Communication Foundation (WCF) e Windows Workflow Foundation

17

(WF). L’ultima versione del Framework (la 3.5 appunto) include LINQ, una revision di ASP.NET e molto altro.Chiaramente non è possibile in questa sede analizzare tutte le nuove caratteristiche, tuttavia possiamo evidenziare alcune delle novità più importanti:

ASP.NET – Il .NET Framework include diversi miglioramenti e novità per gli sviluppatori web. Il namespace System.Web include nuove classi e controlli ed il Framework supporta direttamente la programmazione con AJAX. Tra le altre cose vi sono un nuovo controllo per la visualizzazione dei dati, chiamato ListView, ed un nuovo oggetto, chiamato LinqDataSource, per lavorare con dati LINQ.

LINQ – Il namespace System.Linq definisce gli operatori ed i tipi LINQ standard. Il namespace System.Data.Linq provvede alle connessioni tra i database e i sottosistemi LINQ. Da citare anche altri namespace molto utili: System.Data.Linq.Mapping, System.Xml.Linq. Molti dei controlli del Framework sono stati aggiornati per lavorare con LINQ.

Windows Communication Foundation (WCF) – Il nuovo System.ServiceModel incapsula quello che è conosciuto come WCF. Con questa funzionalità è possibile creare facilmente applicazioni basate su servizi che operano su diversi protocolli.

Windows Presentation Foundation (WPF) – WPF fornisce una nuova tecnologia di presentazione per le applicazioni Windows.

Windows Workflow Foundation (WF) - WF permette di creare per le vostre applicazioni flussi di lavoro sequenziali e guidati dagli stati. Esso è inoltre integrato con WCF, quindi si può facilmente esporre e richiamare un flusso di lavoro come servizio WCF.

Supporto a Windows Vista – Il motore Windows Form è stato aggiornato per rendere le applicazioni compatibili con Windows Vista. Ciò significa che aggiornando le vostre vecchie applicazioni darete ad esse l’aspetto di applicazioni per Vista e potrete utilizzare tutte le finestre di dialogo in stile Vista.

.NET Compact Framework – Il Framework 3.5 fornisce una nuova versione del Compact Framework. Esso può essere utilizzato per dispositivi mobili come Smartphone e dispositivi WindowsMobile\CE.

3.1.3 Linguaggio Visual C#

L’applicativo è stato scritto utilizzando il linguaggio C# presente in Visual Studio 2008. Propongo ora una velocissima panoramica che riguarda proprio C#. Visual C# è basato sulla solida eredità di C++. Immediatamente familiare agli sviluppatori C++ e Java, C# è un linguaggio di programmazione moderno e intuitivo orientato agli oggetti che offre miglioramenti significativi, inclusi un sistema di tipi unificato, il codice di

18

tipo unsafe per conferire agli sviluppatori il massimo controllo e nuovi costrutti potenti e facilmente comprensibili dalla maggior parte degli sviluppatori.

Gli sviluppatori hanno a disposizione un linguaggio innovativo orientato ai componenti, con un supporto intrinseco per proprietà, indexer, delegati, gestione delle versioni, overload degli operatori e attributi personalizzati. Con i commenti XML gli sviluppatori in C# hanno la possibilità di documentare il codice sorgente in modo significativo e utile. Un modello di ereditarietà avanzato consente inoltre agli sviluppatori di riutilizzare il codice scritto in qualsiasi linguaggio di programmazione che supporti .NET.Gli sviluppatori C# possono unirsi a una community di sviluppatori in rapidissima crescita e in quell'ambito scambiare codice e risorse, sfruttare competenze acquisite in diversi ambienti informatici e contribuire al processo di standardizzazione che garantisce la partecipazione attiva alla community.

3.1.4 XPS (XML Paper Specification)

In una prima fase, il programma accetta un CV (tipicamente in formato PDF oppure DOC) e lo converte nel formato XPS per poi analizzarne il contenuto.E’ chiaro, quindi, che è necessario fornire al lettore una panoramica riguardante proprio tale nuovo formato.

Con Windows Vista Microsoft ha introdotto un nuovo formato per l'interscambio di file tra gli utenti, un formato che, come Office OpenXML è bastato sulle specifiche XML. Stiamo parlando di XPS, un nuovo formato che permette di salvare documenti da qualsiasi programma e di leggerli da un reader.

Cosa sono i documenti XPS

XPS abbreviazione di XML Paper Specification, è il formato che Microsoft ha creato durante lo sviluppo di Windows Vista e del .NET Framework 3.0. Conosciuto precedentemente con il nome di "Metro", XPS è un contenitore basato sullo standard di compressione ZIP, con all'interno alcuni file xml e binari che sono visibili semplicemente cambiando l'estensione del file da XPS a ZIP.

I file XPS consentono di essere condivisi tra gli utenti, possono essere creati facilmente da qualsiasi programma, utilizzando Microsoft XPS Document Writer, e mantengono la formattazione dell'originale.

XPS sfrutta Windows Presentation Foundation il sottosistema grafico sviluppato per Windows Vista: in questo modo ci si vuole assicurare che il "rendering" dei file in questo formato sia effettuato nella stessa maniera su qualunque periferica di stampa. E' considerato come il concorrente di Adobe PDF dato che può risultare utile per distribuire documenti (e renderne possibile la visualizzazione in modo univoco e conforme all'originale) anche alle persone non dotate dell'applicazione con cui il file è stato generato, per creare documenti multipagina a partire da contenuti (come può essere una lunga pagina web) non suddivisi

19

per pagine, per archiviare testi ed elaborati con un formato prefissato e comodo da visionare.

Come crearli

I documenti in formato XPS sono realizzabili a partire da qualsiasi programma, se utilizzate Microsoft Office 2007, esiste il comando che permette la creazione di XPS (stessa procedura per la creazione di un PDF).

Salvare documenti XPS da altri programmi, invece, si può fare utilizzando il driver di stampa Microsoft XPS Document Writer, gli utenti di Windows Vista non dovranno installare nulla perché già dispongono di tutte le tecnologie necessarie per la realizzazione dei file XPS. Gli utenti di Windows XP e Windows Server 2003 dovranno installare Microsoft .NET Framework 3.0 e Microsoft XPS Essentials Pack, disponibili gratuitamente sul sito di Microsoft.Per realizzare un documento XPS si dovrà solamente attivare nella finestra stampa di un qualsiasi programma, la stampante virtuale denominata Microsoft XPS Document Writer, successivamente basta fare clic su OK o su Stampa, a seconda del programma utilizzato, e decidere il nome e la posizione del file XPS nella finestra di dialogo Salva il file come.

Come aprirli

I documenti XPS sono al momento visibili solo da Windows Vista, Windows XP e Windows Server 2003, attraverso Internet Explorer 7, come per realizzarli, anche per leggerli su Windows XP e Windows Server 2003, è necessario che siano installati Microsoft .NET Framework 3.0 e Microsoft XPS Essentials Pack visti in precedenza.

20

3.1.5 Interfaccia grafica

Se prendiamo come riferimento una delle tante definizioni di interfaccia grafica presenti su Internet, ad esempio:

“L'interfaccia utente grafica, in sigla GUI (graphical user interface), è un paradigma di sviluppo che mira a consentire all'utente di interagire con il computer manipolando graficamente degli oggetti, svincolandolo dall'obbligo di imparare una serie di comandi da impartire con la tastiera come invece avviene con le più tradizionali interfacce testuali CLI (command line interface). È lo strato di un'applicazione software che si occupa del dialogo con l'utente del sistema utilizzando un ambiente grafico.”

Anche nello sviluppo di questo programma si è cercato di aderire il più possibile a tali principi.Andiamo ora a vedere le sezioni principali presenti nella form dell’applicativo:

Figura 6 - interfaccia grafica

21

Selected document

Settings

Rebuilded document

Source selector

Source content

Una attenzione particolare verso due pulsanti di comando fondamentali per l’intera applicazione:

Figura 7 - scansione e visualizzazione

Scansione documento corrente: fa partire la procedura di acquisizione in due step:

se il file non è nel formato XPS allora lancia una procedura che trasformerà il file in un XPS

se il file è già un XPS allora segue il normale flusso predisposto

Visualizza risultato scansione: visualizza il file XML generato grazie al pulsante visto precedentemente nel rebuilded panel.

Da notare, inoltre, la possibilità per l’utente di creare, modificare ed eliminare diversi modelli di acquisizione del CV. In sostanza, l’operatore è libero di correggere i parametri di scansione e ritentare l’operazione per ottenere un risultato finale migliore.Nelle seguenti figure alcuni esempi:

Figura 8 - scelta modello di scansione

Figura 9 - finestra gestione modelli di scansione

22

3.1.6 Esempio di utilizzo

Vediamo ora quali sono le azioni che l’utente dovrà compiere al fine di ottenere l’acquisizione di un curriculum vitae. Verso la fine di questo capitolo verrà visualizzato come modificare le impostazioni del programma al fine di cambiare il path dei documenti, il numero dei messaggi da visualizzare, il modello di acquisizione ecc.

Selezione del CV da cartella presente nel file system

Il programma presenta l’elenco dei CV presenti nella cartella. E’ possibile eseguire una preview di uno di loro facendo doppio clic sul CV che si intende acquisire.

Figura 10 - selezione CV

Selezione del CV da un allegato presente nella Inbox dell’utente

L’utente sceglie il messaggio che contiene come allegato il CV e opera un semplice doppio clic.

Figura 11 - scelta messaggio con allegato

Verrà proposto dove salvare l’allegato contenente il CV

Figura 12 - scelta cartella per salvataggio allegato

23

Conferma dell’avvenuto salvataggio.

Figura 13 - conferma salvataggio allegato

A questo punto, l’utente potrà selezionare il CV come visto precedentemente.

Anteprima del documento

Una volta deciso quale sia il CV da acquisire, con un doppio clic è possibile ottenerne una anteprima.

Figura 14 - preview del CV da acquisire

Acquisizione

Grazie al pulsante “Scansione documento corrente” sarà possibile convertire il CV dal suo formato originale nel nuovo formato XPS e quindi gestire la scansione mediante appositi parametri a disposizione dell’utente.Notare come la scansione venga eseguita seguendo i parametri di default.

24

Nelle immagini seguenti alcuni screenshots

Figura 15 - pulsante avvio scansione e scelta modello di scansione

Visualizzazione risultato finale

Dopo aver acquisito il CV, è possibile verificare la qualità dell’operazione facendo clic sul pulsante “Visualizza risultato scansione”.

Figura 16 - pulsante per la visualizzazione CV dopo l'acquisizione

Il CV acquisito è stato trasformato in una apposita struttura che suddivide le etichette dai dati veri e propri. L’utente può visualizzare questo facendo clic sugli elementi del CV. Nell’esempio, si può notare come l’etichetta “Data di nascita” venga contraddistinta (colorata) in modo diverso dal contenuto del campo stesso che è “01.01.1980” (giallo)

Figura 17 - com'è strutturato il CV al termine dell'acquisizione

Correzione parametri di scansione

Il programma nasce con alcuni modelli di scansione predefiniti ad esempio “Modello 1”, “Modello 2”. L’utilizzatore può perciò scegliere quale sarà il modello più indicato per il tipo di documento da acquisire oppure può modificare i parametri di scansione in modo temporaneo in qualsiasi istante. E’ inoltre libero di eliminare modelli oppure di crearne di nuovi. La finestra che permette di gestire il tutto è presente in figura X: (raggiungibile facendo clic sul seguente pulsante:

Figura 18 - gestione dei modelli di scansione

25

Figura 19 - finestra per la gestione dei modelli di scansione

Come si può notare, è possibile modificare i singoli valori relativi ad un modello esistente oppure creare un nuovo modello e infine, eliminare un modello esistente.

Impostazioni del programma

Chiude la panoramica relativa all’applicativo la sezione dedicata alle impostazioni relative al programma. La seguente figura visualizza quali sono le modifiche possibili che interessano l’intero applicativo.

Figura 20 - sezione dedicata alle impostazioni generali del programma

Path documenti: la cartella nella quale si trovano i CV Path allegati: la cartella nella quale verranno salvati i CV pervenuti via e-mail Path modelli: dove vengono salvati i modelli di scansione Modello predefinito: qual è il modello di scansione preferito Visualizza mail: il numero di mail da visualizzare

26

3.1.7 Esempi di codice C#

Come anticipato in precedenza, prima di chiudere il 3° capitolo dedicato all’implementazione, propongo alcuni spezzoni di codice C# utilizzati nel programma. Verranno illustrate solo le parti fondamentali che costituiscono l’ossatura del programma stesso.

Impostazioni iniziali del programma

Non appena il programma viene lanciato, l’utente trova già alcune impostazioni “di fabbrica” comunque editabili in seguito. La gestione di tale attività è controllata dalla classe “Settings.cs”. Di seguito un estratto di tale classe:

namespace CVScan {

public class Settings {

private static bool _initialized = false;private static string _settingsFilename = @"\application.ini";private static XmlConfigSource _source;private static string _ApplicationPath = "";

private static string _ApplicationConfigsPath = @"\configs\";private static string _ApplicationLogsPath = @"\logs\";private static string _ApplicationModelsPath = @"\models\";private static string _ApplicationDocsPath = @"docs\";

private static string _ApplicationAttachmentsPath = @"docs\"; private static int _MailMaxFetch = 10; private static string _ApplicationModelDefault = @"";

static Settings() {}

public static void Init() {Init(_settingsFilename);

}

public static void Init(string filename) {Init(filename, "");

}

public static void Init(string filename, string path) {if(_initialized) {

return;}_settingsFilename = filename;

if(path.Length > 0) {_ApplicationPath = path;

} else {string appPath =

System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase);

if(appPath.StartsWith(@"file:\")) {appPath = appPath.Remove(0, 6);

}_ApplicationPath = appPath;

27

}string settingsPath = IOPath.getRootedPath(_settingsFilename,

_ApplicationPath);

if(!File.Exists(settingsPath)) {_source = new XmlConfigSource();_source.Save(settingsPath);

}

_source = new XmlConfigSource(settingsPath);

_source.Alias.AddAlias("True", true);_source.Alias.AddAlias("False", false);

if(_source.Configs.Count == 0) {_source.AddConfig("Main");Save();

}Load();

_initialized = true;}

Figura 21 - classe per la gestione impostazioni programma

Scansione del documento originale

L’utente ha scelto qual è il CV da sottoporre a scansione dall’apposita listbox, ha già ottenuto una anteprima del documento e quindi vuole trasformarlo in una apposita struttura finale. Per ottenere tutto ciò, il programma utilizza più classi che collaborano assieme. Propongo di seguito una immagine chiarificatrice:

Figura 22 - classi utilizzate per la scansione

La prima classe ad essere utilizzata è: File2XPSOmnipageConverter.cs. Lo scopo principale è quello di accettare in ingresso un CV in formato ad esempio PDF oppure DOC e trasformarlo nel formato XPS (sfruttando l’engine Omnipage). Di seguito propongo il codice legato a tale classe:

28

public class File2XPSOmnipageConverter { public static void Convert(string sourceFilename, string destFilename) { EngineClass _engine = new EngineClass(); _engine.Init("Nuance", "OmniPage 16", "", 0, 0); foreach (string filename in Directory.GetFiles(Properties.Settings.Default.SourcePath)) { Document _currentDocument = _engine.Documents.Add(); _currentDocument.RecognitionLanguages[(int)tagLANGUAGES.LANG_ITA].Enabled = true; _currentDocument.LoadImage(filename, -1, -1); _currentDocument. _currentDocument.Recognize(IproPlus.RUNPAGE.);

_currentDocument.Save( Path.Combine( Properties.Settings.Default.DestPath, Path.GetFileNameWithoutExtension(filename) + ".opd" )); } }}

Figura 23 - classe per la trasformazione in formato XPS

A questo punto, abbiamo a disposizione il CV in formato XPS. Il programma ora dovrà analizzare il contenuto dell’XPS, cercare di differenziare le etichette dai dati veri e propri, tener conto delle eventuali modifiche ai parametri di scansione prodotte dall’utente e quindi salvare il tutto nella nuova struttura in formato XML.Il tutto viene gestito dalla classe CVPageLexer.cs (che a sua volta si appoggia ad altre classi quali ad esempio CVToken.cs, CVScanTemplate.cs, ScanEntryComparer.cs ecc.

public class XpsPageLexer: XpsLexer { private static string NS = "http://schemas.microsoft.com/xps/2005/06"; private static clsModel _model = null;

private List<XpsToken> _scans = new List<XpsToken>(); //per leggere da una FixedPage... public static XpsPageLexer Scan(IXpsFixedPageReader pageReader, clsModel model) { _model = model;

XpsPageLexer lexer = new XpsPageLexer();

// step 1: collect in sorted way //recupera le info quali Canvas, Glyphs ecc. ecc. presenti nel documento XDocument xDoc = XDocument.Load(pageReader.XmlReader); XElement fixedPage = xDoc.Element(XName.Get("FixedPage", NS)); double pageWidth = double.Parse(fixedPage.Attribute("Width").Value); double pageHeight = double.Parse(fixedPage.Attribute("Height").Value);

29

foreach (XElement canvas in fixedPage.Elements(XName.Get("Canvas", NS))) { string canvasRenderTransformText = canvas.Attribute("RenderTransform").Value; string[] canvasRenderTransformTexts = canvasRenderTransformText.Split(','); Point p = new Point() { X = Math.Round(double.Parse(canvasRenderTransformTexts[4].Replace(".", ",")), 0), Y = Math.Round(double.Parse(canvasRenderTransformTexts[5].Replace(".", ",")), 0) };

foreach (XElement glyphs in canvas.Elements(XName.Get("Glyphs", NS))) { string unicodeString = glyphs.Attribute(XName.Get("UnicodeString")).Value; string glyphsRenderTransformText = glyphs.Attribute("RenderTransform").Value;

// step 1.1: candidate labels and values if (p.X < _model.SepVert) { if (lexer._scans.Count > 0) { //supponiamo che siano vicini....a livello di X e Y string old = lexer._scans[lexer._scans.Count - 1].Text; double oldX = lexer._scans[lexer._scans.Count - 1].Location.X; double oldY = lexer._scans[lexer._scans.Count - 1].Location.Y; if((p.X - oldX) < _model.Dist_X && (p.Y - oldY) < _model.Dist_Y) { XpsToken se = new XpsNonTerminalToken(); lexer._scans[lexer._scans.Count - 1].Text = old + unicodeString; } else { XpsToken se = new XpsNonTerminalToken(); se.Text = unicodeString; se.Location = new Point(p.X - _model.Off_X, p.Y - _model.Off_Y); // offset to be parametrized lexer._scans.Add(se); } } else { //richiama CVToken.cs...e CVTerminalToken XpsToken se = new XpsNonTerminalToken(); se.Text = unicodeString; se.Location = new Point(p.X - 2, p.Y - 2); // offset to be parametrized lexer._scans.Add(se); }

}

else { XpsToken se = new XpsTerminalToken(); se.Text = unicodeString; se.Location = new Point(p.X + 2, p.Y + 2); // offset to be parametrized

lexer._scans.Add(se); }

30

} }

lexer._i = 0;

lexer._scans.Sort(ScanEntryComparer.Default);

return lexer; }

private int _i; private XpsToken _current;

public XpsToken Current { get { return _current; } }

public XpsToken Next() { if (_i == _scans.Count) { _current = null; return null; }

_current = _scans[_i++];

return _current; } }}

Figura 24 - la classe CVPageLexer.cs

Terminata questa fase, otteniamo un nuovo file in formato XML che rappresenta il CV originale con tutte le informazioni in esso contenute disponibili per ulteriori utilizzi futuri.In sostanza, il programma è riuscito ad estrarre dal CV originale (ad esempio in formato PDF) tutte le informazioni che poi andranno a popolare un archivio.Se andiamo infatti a visualizzare la struttura XML del CV una volta terminata la fase di scansione, potremmo verificare che i dati contenuti nel CV originale, sono effettivamente disponibili e analizzabili facilmente da programmi che si occupano di gestire files XML.

  <?xml version="1.0" encoding="utf-8" ?> - <root>  <other name="FORMATO EUROPEO" location="96;88" />   <other name="PER IL CURRICULUM" location="93;112" />   <other name="VITAE" location="208;132" /> - <label name="INFORMAZIONI PERSONALI" location="115;222">- <label name="Nome" location="227;258">  <value name="Mario Rossi" location="259;263" />

  </label>- <label name="Indirizzo" location="216;281">  <value name="Via Lenta,15" location="259;286" />

  </label>- <label name="Telefono" location="213;305">  <value name="0434 000000" location="259;310" />

  </label>  <label name="Fax" location="238;328" /> - <label name="E-mail" location="225;352">

31

  <value name="XXX@XXX.it" location="259;357" />   <value name="CXX.it" location="331;357" />

  </label>- <label name="Nazionality" location="202;395">  <value name="italiana" location="259;399" />

  </label>- <label name="Data di nascita" location="184;423">  <value name="01.01.1980" location="259;427" />

  </label>  </label>

- <label name="ESPERIENZA LAVORATIVA" location="118;474">- <label name="•Date (da —a)" location="193;508">  <value name="01.06.1996 a 31.12.2003" location="267;511" />

  </label>- <label name="•Nome e indirizzo del datore di lavoro" location="79;526">  <value name="Wurth s.r.l" location="267;529" />

  </label>- <label name="•Tipo di azienda o settore" location="137;544">  <value name="Azienda commerciale. settore sistemi e prodotti di fissaggio"

location="267;547" />   </label>

- <label name="•Tipo di impiego" location="183;562">  <value name="Ag. Commercio/ Funzionario commerciale" location="301;564" />

  </label>- <label name="•Principali mansioni e responsability" location="86;580">  <value name="vendita" location="302;584" />

  </label>  <label name="ESPERIENZA LAVORATIVA" location="118;597" /> - <label name="•Date (da —a)" location="193;631">  <value name="01.01.2004 ad 20.10.2004" location="267;634" />

  </label>- <label name="•Nome e indirizzo del datore di lavoro" location="79;649">  <value name="Dominoni s.r.l" location="267;652" />

  </label>- <label name="•Tipo di azienda o settore" location="137;667">  <value name="Commerciale. Impianti condizionamento aria condizionata autoveicoli"

location="267;670" />   </label>

- <label name="•Tipo di impiego" location="183;685">  <value name="Funzionario commercilae" location="302;688" />

  </label>  <label name="•Principali mansioni e responsability" location="86;703" />   <label name="ESPERIENZA LAVORATIVA" location="118;721" /> - <label name="•Date (da —a)" location="193;755">  <value name="21.10.2004 ad oggi" location="267;758" />

  </label>- <label name="•Nome e indirizzo del datore di lavoro" location="79;773">  <value name="Vaillant Saunier Duval italia S.p.a" location="267;775" />

  </label>- <label name="•Tipo di azienda o settore" location="137;791">  <value name="Azienda commerciale. Settore riscaldamento condizionamento"

location="267;793" />   </label>

- <label name="•Tipo di impiego" location="183;809">  <value name="Funzionario Commerciale." location="302;812" />

  </label>- <label name="•Principali mansioni e responsability" location="86;827">  <value name="Vendita. Responsabile commerciale riscaldamento sulla provincia di Milano"

location="302;831" />   </label>  </label>

- <label name="ISTRUZIONE E FORMAZIONE" location="110;859">  <other name="•Date (da —a)" location="185;894" />   <value name="1994" location="294;898" />   <value name="-" location="294;898" />

32

  <value name="1989" location="294;898" /> - <label name="•Nome e tipo di istituto di istruzione" location="82;911">  <value name="Collegio Villoresi San Giuseppe" location="293;916" />   <other name="o formazione" location="193;927" />

  </label>- <label name="•Principali materie / ability" location="127;945">  <value name="Economico Aziendale" location="294;949" />   <other name="professionali oggetto dello studio" location="97;960" />

  </label>- <label name="•Qualifica conseguita" location="150;979">  <value name="Ragioniere" location="294;982" />

  </label>- <label name="•Livello nella classificazione" location="118;996">  <value name="39/60" location="293;1000" />   <other name="nazionale (se pertinente" location="136;1011" />   <value name=")" location="257;1026" />

  </label>  </label>  </root>

Figura 25 - file XML risultato della scansione

33

4 - CONCLUSIONI

Penso di poter affermare che l’obiettivo di realizzare una Windows - application, che consenta all’utente di poter convertire curriculum vitae pervenuti in formato cartaceo oppure in formati quali PDF, DOC ecc verso un formato che permetta in seguito di poter recuperare i dati sia stato raggiunto.L’applicazione si presenta con un’interfaccia semplice ed intuitiva, perciò non richiede da parte dell’utente un grande sforzo per capire come devono essere utilizzati i vari componenti e le varie funzionalità che costituiscono l’applicazione.L’applicazione è naturalmente suscettibile di ulteriori perfezionamenti e dovrebbe essere ulteriormente testata a fondo con opportuni test cases.Non è stata inserita la funzionalità che riguarda il “dopo scansione” ovvero come gestire i files (CV) in formato XML. Questo perché il tutto dipende dal gestionale presente nell’Azienda dove il programma verrà utilizzato.Tra gli sviluppi futuri vedo anche la possibilità di estendere il salvataggio di allegati non solo provenienti dalla mailbox di Outlook aziendale ma anche da caselle di posta di tipo POP3.Ovviamente, il programma potrebbe essere anche riprogettato al fine di poterlo trasformare in una Web – Application e quindi utilizzabile da più persone contemporaneamente mediante il proprio Web-Browser…dipende sempre dal contesto nel quale si troverà ad operare…

34

5 - RINGRAZIAMENTI

Ringrazio innanzitutto il Prof. Fermeglia Maurizio per la sua disponibilità umana nei miei confronti e per avermi assegnato una tesi così interessante e dai contenuti tecnologici moderni.Un ringraziamento doveroso verso il Dott. Parenzan Marco che mi ha seguito nella stesura del programma e mi ha arricchito con i suoi consigli preziosissimi in termini di Object Oriented Programming.Non posso naturalmente dimenticare di ringraziare mia moglie Daniela e i figli Nicole e Manuel per la pazienza dimostrata nel periodo in cui ero occupato con gli studi. Ora potrò dedicarmi di più a loro…

Roberto

35

Bibliografia

Beginning C# 2008 From Novice to Professional SECOND EDITIONChristian Gross APRESS

Professional Visual Studio® 2008Nick RandolphDavid GardnerWiley Publishing, Inc.

Ricerche varie effettuate mediante motore di ricerca www.google.it

36

Indice delle figure

Figura 1 – architettura .NET Framework...................................................................................................9Figura 2 – Use Case diagram...................................................................................................................11Figura 3 – Activity diagram.....................................................................................................................12Figura 4 - Class Diagram.........................................................................................................................14Figura 5 – scelta versione framework......................................................................................................16Figura 6 - interfaccia grafica....................................................................................................................21Figura 7 - scansione e visualizzazione.....................................................................................................22Figura 8 - scelta modello di scansione.....................................................................................................22Figura 9 - finestra gestione modelli di scansione.....................................................................................22Figura 10 - selezione CV.........................................................................................................................23Figura 11 - scelta messaggio con allegato...............................................................................................23Figura 12 - scelta cartella per salvataggio allegato..................................................................................23Figura 13 - conferma salvataggio allegato...............................................................................................24Figura 14 - preview del CV da acquisire.................................................................................................24Figura 15 - pulsante avvio scansione e scelta modello di scansione.......................................................25Figura 16 - pulsante per la visualizzazione CV dopo l'acquisizione.......................................................25Figura 17 - com'è strutturato il CV al termine dell'acquisizione.............................................................25Figura 18 - gestione dei modelli di scansione..........................................................................................25Figura 19 - finestra per la gestione dei modelli di scansione...................................................................26Figura 20 - sezione dedicata alle impostazioni generali del programma.................................................26Figura 21 - classe per la gestione impostazioni programma....................................................................28Figura 22 - classi utilizzate per la scansione............................................................................................28Figura 23 - classe per la trasformazione in formato XPS........................................................................29Figura 24 - la classe CVPageLexer.cs.....................................................................................................31Figura 25 - file XML risultato della scansione........................................................................................33

37