Università degli Studi di Trieste
                              Facoltà di Ingegneria


                  Corso di Laurea ...
Sommario

1 - INTRODUZIONE...................................................................................................
1 - INTRODUZIONE
In questa tesi si vuole descrivere la progettazione e lo sviluppo di una applicazione che
permetta di acq...
Nella prima parte verrà illustrata l’analisi e la progettazione del sistema da realizzare. In
particolare saranno esposte ...
2 – ANALISI
In questa prima parte del documento viene presentata un’analisi del sistema che si andrà a
realizzare. Si iniz...
2.1 – Analisi del sistema


2.1.1 – Il progetto

Come già anticipato nell’introduzione, il progetto          richiede la c...
2.1.3 – L’ambiente di sviluppo


   Per sviluppare l’applicazione è stato utilizzato L’IDE Microsoft Visual Studio 2008 e ...
 Scan current:
   il software deve essere in grado di acquisire CV con formati diversi ad esempio .DOC,
   .RTF, .XPS e q...
2.2 – Progettazione del sistema
2.2.1 – L’architettura

L’architettura di un prodotto software rappresenta il modo con cui...
Una libreria costituita da codice aderente al CLS è chiamata "CLS Framework". Queste
librerie sono progettate per essere u...
I runtime non rappresentano una novità per i linguaggi: molti linguaggi di programmazione
possiedono un runtime. Visual Ba...
L’attore del sistema è unico e coincide con l’utente finale che svolge le funzioni di
caricamento e conversione dei CV.


...
2.2.5 – Class diagram

Il diagramma delle classi descrive il sistema generale, la sua struttura statica, ovvero la sua
mod...
Figura 4 - Class Diagram


          14
3 - REALIZZAZIONE
In questa seconda unità del documento viene presentata la fase di implementazione della
Windows-Applicat...
3.1 Implementazione


3.1.1 Visual Studio

L’intero applicativo è stato sviluppato all’interno dell’ambiente Visual Studio...
Si può anche decidere di convertire un’applicazione in una versione differente del .NET
Framework.

Se si utilizza Visual ...
(WF). L’ultima versione del Framework (la 3.5 appunto) include LINQ, una revision di
ASP.NET e molto altro.
Chiaramente no...
tipo unsafe per conferire agli sviluppatori il massimo controllo e nuovi costrutti potenti e
facilmente comprensibili dall...
per pagine, per archiviare testi ed elaborati con un formato prefissato e comodo da
visionare.

Come crearli

I documenti ...
3.1.5 Interfaccia grafica

  Se prendiamo come riferimento una delle tante definizioni di interfaccia grafica presenti su
...
Una attenzione particolare verso due pulsanti di comando fondamentali per l’intera
applicazione:




                     ...
3.1.6 Esempio di utilizzo

Vediamo ora quali sono le azioni che l’utente dovrà compiere al fine di ottenere
l’acquisizione...
Conferma dell’avvenuto salvataggio.




                           Figura 13 - conferma salvataggio allegato

A questo pun...
Nelle immagini seguenti alcuni screenshots



                 Figura 15 - pulsante avvio scansione e scelta modello di sc...
Figura 19 - finestra per la gestione dei modelli di scansione

Come si può notare, è possibile modificare i singoli valori...
3.1.7 Esempi di codice C#

Come anticipato in precedenza, prima di chiudere il 3° capitolo dedicato
all’implementazione, p...
}
                         string settingsPath = IOPath.getRootedPath(_settingsFilename,
 _ApplicationPath);

            ...
public class File2XPSOmnipageConverter
     {
         public static void Convert(string sourceFilename, string destFilena...
foreach (XElement canvas in fixedPage.Elements(XName.Get("Canvas", NS)))
            {
                string canvasRender...
}
              }

              lexer._i = 0;

              lexer._scans.Sort(ScanEntryComparer.Default);

             ...
- <label name="E-mail" location="225;352">
  <value name="XXX@XXX.it" location="259;357" />
  <value name="CXX.it" locatio...
</label>
- <label name="ISTRUZIONE E FORMAZIONE" location="110;859">
  <other name="•Date (da —a)" location="185;894" />
 ...
4 - CONCLUSIONI

Penso di poter affermare che l’obiettivo di realizzare una Windows - application, che
consenta all’utente...
5 - RINGRAZIAMENTI



Ringrazio innanzitutto il Prof. Fermeglia Maurizio per la sua disponibilità umana nei miei
confronti...
Bibliografia


   Beginning C# 2008 From Novice to Professional SECOND EDITION
    Christian Gross
    APRESS

   Profes...
Indice delle figure

Figura 1 – architettura .NET Framework..................................................................
Upcoming SlideShare
Loading in …5
×

SVILUPPO DI UNA APPLICAZIONE PER L’ACQUISIZIONE DI DATI DA SUPPORTO CARTACEO: CASO DEI CURRICULUM VITAE

2,020 views
1,892 views

Published on

Tesi di laurea (Word) Faelli Roberto dal titolo "SVILUPPO DI UNA APPLICAZIONE PER L’ACQUISIZIONE DI DATI DA SUPPORTO CARTACEO: CASO DEI CURRICULUM VITAE"

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

  • Be the first to like this

No Downloads
Views
Total views
2,020
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
31
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

SVILUPPO DI UNA APPLICAZIONE PER L’ACQUISIZIONE DI DATI DA SUPPORTO CARTACEO: CASO DEI CURRICULUM VITAE

  1. 1. 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: Laureando: Prof. Fermeglia Maurizio Faelli Roberto Anno Accademico 2008/2009
  2. 2. Sommario 1 - INTRODUZIONE...........................................................................................................................3 2 – ANALISI........................................................................................................................................5 2.1 – Analisi del sistema...................................................................................................................6 2.1.1 – Il progetto.........................................................................................................................6 2.1.2 – Utenza...............................................................................................................................6 2.1.3 – L’ambiente di sviluppo.....................................................................................................7 2.1.4 – Definizione dei requisiti...................................................................................................7 2.2 – Progettazione del sistema........................................................................................................9 2.2.1 – L’architettura....................................................................................................................9 2.2.2 – Use Case Diagram..........................................................................................................11 2.2.4 – Activity diagram.............................................................................................................12 2.2.5 – Class diagram.................................................................................................................13 3 - REALIZZAZIONE.......................................................................................................................15 3.1 Implementazione......................................................................................................................16 3.1.1 Visual Studio.....................................................................................................................16 3.1.2 Le novità del .NET Framework 3.5...................................................................................17 3.1.3 Linguaggio Visual C#........................................................................................................18 3.1.4 XPS (XML Paper Specification).......................................................................................19 3.1.5 Interfaccia grafica..............................................................................................................21 3.1.6 Esempio di utilizzo............................................................................................................23 3.1.7 Esempi di codice C#..........................................................................................................27 4 - CONCLUSIONI............................................................................................................................34 5 - RINGRAZIAMENTI....................................................................................................................35 2
  3. 3. 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
  4. 4. 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
  5. 5. 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
  6. 6. 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
  7. 7. 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
  8. 8.  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
  9. 9. 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
  10. 10. 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
  11. 11. 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
  12. 12. 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
  13. 13. 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
  14. 14. Figura 4 - Class Diagram 14
  15. 15. 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
  16. 16. 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
  17. 17. 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
  18. 18. (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 WindowsMobileCE. 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
  19. 19. 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
  20. 20. 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
  21. 21. 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: Source Settings selector Source Selected Rebuilded content document document Figura 6 - interfaccia grafica 21
  22. 22. 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
  23. 23. 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
  24. 24. 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
  25. 25. 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
  26. 26. 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
  27. 27. 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().CodeB ase); if(appPath.StartsWith(@"file:")) { appPath = appPath.Remove(0, 6); } _ApplicationPath = appPath; 27
  28. 28. } 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
  29. 29. 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
  30. 30. 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
  31. 31. } } 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" /> 31
  32. 32. - <label name="E-mail" location="225;352"> <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> 32
  33. 33. </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" /> <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
  34. 34. 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
  35. 35. 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
  36. 36. Bibliografia  Beginning C# 2008 From Novice to Professional SECOND EDITION Christian Gross APRESS  Professional Visual Studio® 2008 Nick Randolph David Gardner Wiley Publishing, Inc.  Ricerche varie effettuate mediante motore di ricerca www.google.it 36
  37. 37. Indice delle figure Figura 1 – architettura .NET Framework...................................................................................................9 Figura 2 – Use Case diagram...................................................................................................................11 Figura 3 – Activity diagram.....................................................................................................................12 Figura 4 - Class Diagram.........................................................................................................................14 Figura 5 – scelta versione framework......................................................................................................16 Figura 6 - interfaccia grafica....................................................................................................................21 Figura 7 - scansione e visualizzazione.....................................................................................................22 Figura 8 - scelta modello di scansione.....................................................................................................22 Figura 9 - finestra gestione modelli di scansione.....................................................................................22 Figura 10 - selezione CV.........................................................................................................................23 Figura 11 - scelta messaggio con allegato................................................................................................23 Figura 12 - scelta cartella per salvataggio allegato..................................................................................23 Figura 13 - conferma salvataggio allegato...............................................................................................24 Figura 14 - preview del CV da acquisire.................................................................................................24 Figura 15 - pulsante avvio scansione e scelta modello di scansione........................................................25 Figura 16 - pulsante per la visualizzazione CV dopo l'acquisizione........................................................25 Figura 17 - com'è strutturato il CV al termine dell'acquisizione..............................................................25 Figura 18 - gestione dei modelli di scansione..........................................................................................25 Figura 19 - finestra per la gestione dei modelli di scansione...................................................................26 Figura 20 - sezione dedicata alle impostazioni generali del programma.................................................26 Figura 21 - classe per la gestione impostazioni programma....................................................................28 Figura 22 - classi utilizzate per la scansione............................................................................................28 Figura 23 - classe per la trasformazione in formato XPS........................................................................29 Figura 24 - la classe CVPageLexer.cs......................................................................................................31 Figura 25 - file XML risultato della scansione........................................................................................33 37

×