Tesi Marco Ventura

UNIVERSITÀ DEGLI STUDI DI TRIESTE
FACOLTÀ DI INGEGNERIA
Corso di Laurea in Ingegneria Informatica

SVILUPPO DI UN APPLICATIVO
SOFTWARE PER LA RICERCA DI
INFORMAZIONI IN FILE CAD

Laureando: Relatore:
Marco VENTURA Chiar.mo Prof. Maurizio FERMEGLIA

Anno Accademico 2007- 2008

SOMMARIO

Capitolo 1 INTRODUZIONE 1
1.1 PREFAZIONE 1

Capitolo 2 ANALISI 3
2.1 STUDIO DELLE TECNOLOGIE 3
2.1.1 CAD: Computer Aided Drafting 3
 DWG: DraWinG 3
 DXF: Drawing eXhange Format 4
2.1.2 .NET FRAMERWORK 3.5 5
 C# 6
2.1.3 CAD Import.Net 7
2.1.4 SQL: Structured Query Language 7
 MICROSOFT SQL SERVER 7
2.1.5 XML: eXtensible Markup Language 8
 L’XML Schema Definition 9
2.2 RACCOLTA DEI REQUISITI 10

Capitolo 3 REALIZZAZIONE DEL SOFTWARE 11
3.1 PROGETTAZIONE LOGICA 11
 STRUTTURA SOFTWARE 11
 CLASSI, STRUTTURA E FUNZIONAMENTO 13
 FILE DI CONFIGURAZIONE 15
 INTERFACCIA GRAFICA 17
 ARCHITETTURA DATABASE 17
 STRUTTURA DEL DOCUMENTO DI INDICE IN XML 18
3.2 PROGETTAZIONE FISICA 21
 INTERFACCIA E FUNZIONALITA’ 21
 REALIZZAZIONE DATABASE 24
 COMMENTO DEL CODICE 26
- Lettura del file di configurazione 26
- Caricamento del viewer CAD 27
- Caricamento e scansione degli elementi del disegno 28
- Invio dei dati al DB 28
 TEST 32

Capitolo 4 CONCLUSIONI 34

Appendice A ABBREVIAZIONI USATE 36

Appendice B ELENCO DELLE IMMAGINI 38

Appendice C BIBLIOGRAFIA 39

INTRODUZIONE

Capitolo 1
INTRODUZIONE

1.1 PREFAZIONE

A partire dagli anni Settanta, si ebbero le prime applicazioni
commerciali del CAD (Computer Aided Design, cioè Progettazione
Assistita da Elaboratore) in grandi aziende elettroniche, automobilistiche
ed aerospaziali.
Da allora l’impiego e la distribuzione di tali applicazioni è aumentato
in maniera considerevole, e con esso la generazione, lo scambio e
l’archiviazione dei files da essi generati. Il DWG è il formato di files per
disegni CAD utilizzato da Autodesk per il proprio software AutoCAD ed è
di fatto il formato CAD più diffuso al mondo.

Questi files contengono informazioni vitali per l’azienda: è
fondamentale per la stessa archiviarli per poter in seguito cercare tra essi
informazioni utili a rieseguire un lavoro analogo. A seguito del tirocinio
svolto con la supervisione del Professor Fermeglia, inserito all’interno di
un progetto di gestione di questi contenuti, mi è stato affidato il compito
specifico di cercare un’adeguata soluzione per la gestione dello specifico
problema di selezione, classificazione e archiviazione di questi contenuti.

Certamente esistono in commercio programmi che gestiscono
l’archiviazione di files, ma la peculiarità che contraddistingue questo lavoro

1

INTRODUZIONE

è data dall’estrapolazione e la successiva organizzazione dei contenuti dei
files in speciali files di indicizzazione.
Lo scopo della tesi è quello di creare un software in grado di
estrarre le informazioni dai files CAD, organizzarle all’interno di files XML e
di poterle memorizzare in un database. Per far ciò, il programma da
realizzare dovrà essere in grado di:
• individuare automaticamente i files CAD all’interno di determinate
directory
• permettere la visualizzazione del file selezionato
• estrarre da esso le proprietà ed i contenuti in files XML
• organizzare le informazioni raccolte ed i files stessi all’interno di un
database

Per conseguire tale obiettivo è necessario passare attraverso
diverse fasi di lavoro:
• studio delle tecnologie
• raccolta dei requisiti
• progettazione
• realizzazione del software

Tali punti vengono sviluppati ampiamente nei capitoli seguenti
inerenti l’analisi e la realizzazione.

2

ANALISI

Capitolo 2
ANALISI

2.1 STUDIO DELLE TECNOLOGIE

2.1.1 CAD: Computer Aided Drafting

Nella accezione più comune, CAD indica il settore dell'informatica
volto all'utilizzo di tecnologie software, specificamente della computer
grafica, per supportare l'attività di disegno tecnico e attività di
progettazione (design) di manufatti sia virtuale che reali.
I sistemi di Computer Aided Drafting hanno come obiettivo la
creazione di un modello, tipicamente 2D, del disegno tecnico che descrive
il manufatto.

 DWG: DraWinG

Formato di files sviluppato da Autodesk. Fu introdotto nel dicembre
del 1982 insieme ad AutoCAD 1.0, unitariamente al formato per la
esportazione verso altri sistemi CAD, ovvero il dxf. Autodesk non ha mai
rilasciato specifiche sul formato, forse proprio per la natura di “proprio
strumento” contrapposta alla proposizione dello standard dxf.
È un file binario suddiviso in molteplici sezioni e con una
memorizzazione complessa dei dati (si ritiene deprecabile la scrittura o
modifica ad accesso diretto al file).
Il dwg non è uno standard. Nonostante sia largamente diffuso e la
maggior parte delle case di programmazione che sviluppano sistemi CAD

3

ANALISI

dichiarino ad oggi la compatibilità con tale formato, la proprietà esclusiva e
la conseguente variabilità dello stesso al variare delle release di prodotto,
lo rendono uno strumento poco adatto allo scambio di dati tra CAD diversi.

Nel rilasciare le nuove versioni di AutoCAD con scadenza annuale,
il formato dwg viene variato mediamente ogni tre versioni rendendolo
incompatibile verso l’alto ma non verso il basso.

 DXF: Drawing eXhange Format

Formato di files sviluppato da Autodesk per lo scambio di dati tra
AutoCAD ed altre applicazioni di grafica vettoriale. Essi sono dei normali
files di testo che possono essere editati con semplici editor ascii
opzionalmente per limitarne l’ingombro essi possono essere compilati in
formato binario. Fu introdotto originariamente nel dicembre 1982 insieme
ad AutoCAD 1.0, e consentì una rappresentazione esatta dei dati del
formato originale di AutoCAD (dwg), per il quale Autodesk non ha mai
rilasciato le specifiche.

La versione ascii del formato dxf può essere visualizzato con un
editor di testi, la struttura di base è la seguente:
• header: contiene le variabili generali associate al disegno (limiti,
estensioni, quotature,..);
• classes: vengono definite le classi (dizionario, tratteggio,..);
• tables: tabelle contenenti le caratteristiche dei diversi oggetti (layer,
stili, viste, tipi linea,..);
• blocks: descrive i singoli blocchi contenuti nel disegno;
• entities: la sezione più importante che riporta tutti gli oggetti grafici
presenti nel disegno (linee, archi, cerchi, tratteggi,..);
• objects: contiene tutti gli oggetti non grafici associati al disegno.

Non è necessario la presenza di tutte le sezioni.

4

ANALISI

2.1.2 .NET FRAMERWORK 3.5

Il framework è una struttura di supporto su cui un software può
essere organizzato e progettato. Alla base di un framework c'è sempre
una serie di librerie di codice utilizzabili con uno o più linguaggi di
programmazione, spesso corredate da una serie di strumenti di supporto
allo sviluppo del software.
.NET, creata dalla Microsoft, è una versatile piattaforma di sviluppo
software basata sulla tecnologia di programmazione ad oggetti.
Realizzato come contrapposizione proprietaria al linguaggio Java
(che è open source), ha un ruolo strategico per la Microsoft come
piattaforma di sviluppo per applicazioni desktop e server per le architetture
client/server, internet ed intranet. Rispetto a Java, .Net (e il suo linguaggio
principe, cioè C#) sono standard ISO riconosciuti e quindi non è possibile,
da parte della casa madre, modificarne la sintassi (a meno di discostarsi
dal suo stesso standard).

La prima versione di .NET è stata rilasciata nel 2002. La sua
caratteristica peculiare è di essere indipendente dalla versione operativa
di Windows su cui è installata, e di includere molte funzionalità progettate
espressamente per integrarsi in ambiente internet e garantire il massimo
grado di sicurezza e integrità dei dati.

Il framework è corredato da una serie di strumenti di sviluppo delle
applicazioni, progettati in modo da funzionare integratamente all'interno
della piattaforma. Uno dei principali strumenti è l'IDE (Integrated
Development Environment cioè Ambiente di sviluppo integrato)
denominato Visual Studio.

La CLI, Common Language Infrastructure (una specifica aperta
sviluppata da Microsoft, che descrive il codice eseguibile) è concepita per
essere compatibile con qualsiasi linguaggio di alto livello orientato agli

5

ANALISI

oggetti, fornendo un unico modello a oggetti ed una vasta libreria di classi
condivisibili.
L’ultima versione del .NET framework è la 3.5, rilasciata a
novembre del 2007.

 C#

Il C# è un linguaggio di programmazione object-oriented sviluppato
da Microsoft all'interno dell'iniziativa .NET. La sintassi del C# prende
spunto da quella del Delphi, del C++, da quella di Java ed a Visual Basic
per gli strumenti di programmazione visuale e per la sua semplicità. In un
certo senso è il linguaggio che meglio degli altri descrive le linee guida
sulle quali ogni programma .NET viene eseguito; è stato infatti creato da
Microsoft specificatamente per la programmazione nel framework .NET. I
suoi tipi di dati quot;primitiviquot; hanno una corrispondenza univoca con i tipi .NET
e molte delle sue astrazioni, come classi, interfacce, delegati ed eccezioni,
sono particolarmente adatte a gestire il .NET framework.

Così come Java ha i suoi package, anche nel C# possiamo
ritrovare una serie di classi già sviluppate per l'interazione con i vari
ambienti, Front End, Database, Xml e altri. Questo è il .NET framework,
del quale utilizza una serie di librerie di classi che gli permettono l'accesso
alle funzionalità del sistema. In C# quello che in Java è chiamato package
viene chiamato namespace o quot;spazi di nomiquot;. Le classi sono organizzate
all'interno di una serie di namespace che raggruppano le classi con
funzionalità simili; ad esempio System.Windows.Forms per la gestione
delle finestre di tipo quot;Formsquot;, System.Xml per l'elaborazione di XML e
System.Data per l'accesso alle basi dati.

Un ulteriore livello di organizzazione è costituito dagli quot;assemblyquot;,
che può essere un singolo file od una serie di file collegati fra di loro ed
avere al suo interno diversi spazi di nomi.

6

ANALISI

2.1.3 CAD Import.Net

Realizzata per gli sviluppatori di .NET, è una libreria per la visione,
l’importazione, la conversione e l’editing dei files CAD. Di essa esiste una
versione shareware ed una a pagamento. Entrambe sono realizzate dalla
Soft Gold, un’azienda russa fondata nel 2000 specializzata in applicazioni,
librerie e plug-in per software CAD.

2.1.4 SQL: Structured Query Language

Linguaggio creato per l'accesso a informazioni memorizzate nei
database, l’SQL nasce come strumento per lavorare con database che
seguano il modello relazionale. Il modello entità-relazioni (E/R) viene
adoperato per analizzare le caratteristiche di una situazione, prescindendo
dagli eventi che si verificheranno. Ciò al fine di costituire un modello
concettuale di dati sentito come indipendente dalle applicazioni.

Il modello entità associazione si distingue per la presenza di vari
elementi che lo definiscono:
1. le entità, oggetti che avranno un particolare senso e vengono
classificati secondo criteri particolari;
2. le associazioni, legami che si formano tra due entità;
3. gli attributi, caratteristiche che qualificano e contrassegnano le
entità.

 MICROSOFT SQL SERVER

SQL Server è un DBMS relazionale prodotto da Microsoft. Nelle
prime versioni era utilizzato per basi dati medio-piccole, ma a partire dalla
versione 2000 è stato utilizzato anche per la gestione di basi dati di grandi
dimensioni.

7

ANALISI

Microsoft SQL Server usa una variante del linguaggio SQL
standard (lo standard ISO certificato nel 1992) chiamata T-SQL Transact-
SQL. Comunica sulla rete utilizzando un protocollo a livello di applicazione
chiamato quot;Tabular Data Streamquot; (TDS). SQL Server supporta anche
quot;Open Database Connectivityquot; (ODBC). Il servizio di SQL Server risponde
per default sulla porta 1433.

2.1.5 XML: eXtensible Markup Language

L’XML è un metalinguaggio di markup, ovvero un linguaggio
marcatore che definisce un meccanismo sintattico che consente di
estendere o controllare il significato di altri linguaggi marcatori
permettendo di creare tag personalizzati.
L’XML è uno strumento che permette di essere utilizzato nei più
diversi contesti, dalla definizione della struttura di documenti, allo scambio
delle informazioni tra sistemi diversi, dalla rappresentazione di immagini
alla definizione di formati di dati.
Esso è utilizzato anche come mezzo per l’esportazione di dati tra
diversi DBMS.

Un documento XML nella prima riga riporta la versione in uso e
specifica la codifica ISO per la corretta interpretazione dei dati. Non
riconosce i caratteri speciali all’interno di una sua struttura (lettere
accentate, la & ed altri vanno quindi sostituiti con le rispettive sequenze
UNICODE).

Come l’HTML, l’XML utilizza dei marcatori chiamati tag per
assegnare una semantica al testo. Rigido nella sintassi da seguire rispetto
all’HTML ed è pertanto necessario rispettare alcune regole:
• i tag non possono iniziare con numeri o caratteri speciali e non
possono contenere spazi;

8

ANALISI

• i tag devono essere bilanciati, ovvero non sono consentiti errori
di annidamento.

Nell’XML, che è case sensitive, è possibile anche definire tag vuoti
che vengono aperti e immediatamente chiusi.
Per poter essere correttamente interpretato, deve essere well
formed (ben formattato), cioè deve possedere le seguenti caratteristiche:
• un prologo, che è la prima istruzione che appare scritta nel
documento. Un esempio può essere: <?xml version=quot;1.0quot;
encoding=quot;ISO-8859-1quot;?>;
• un unico elemento radice (ovvero il nodo principale, chiamato
root element) che contiene tutti gli altri nodi del documento. Ad
esempio: <root>;
• all'interno del documento tutti i tag devono essere bilanciati.

Se il documento è well formed e rispetta i requisiti strutturali
dell’XML Schema, viene dichiarato Valid (valido).

 L’XML Schema Definition

L'XML Schema è l'unico linguaggio di descrizione del contenuto di
un file XML. Il suo scopo è delineare quali elementi sono permessi, quali
tipi di dati sono ad essi associati e quale relazione gerarchica hanno fra
loro gli elementi contenuti in un file XML. Ciò permette principalmente la
validazione del file XML, ovvero la verifica che i suoi elementi siano in
accordo con la descrizione in linguaggio XML Schema.

9

ANALISI

2.2 RACCOLTA DEI REQUISITI

L’applicazione dovrà funzionare in un ambiente Windows. Il
software verrà creato, sfruttando il framerwork .NET 3.5, nell’ambiente di
sviluppo Visual studio 2008. Il linguaggio adottato sarà il C#.
I files su cui si opererà saranno quelli di estensione .dwg e .dxf.
Per quanto riguarda le varie elaborazioni dei files CAD, ci si
avallerà della libreria CAD Import.Net 6.3 versione shareware della Soft
Gold.
Alcuni dei files di configurazione, e parte dei dati estratti, verranno
strutturati in XML.
I dati raccolti saranno organizzati in un database relazionale
realizzato tramite il SQL Server 2008 versione express.
La piattaforma software sarà configurabile mediante un file XML di
configurazione. Essa sarà modulabile, prevedendo l’inserimento di altri
moduli.

10

REALIZZAZIONE DEL SOFTWARE

Capitolo 3

3.1 PROGETTAZIONE LOGICA

 STRUTTURA SOFTWARE

Un aspetto importate di questa fase è come strutturare la
piattaforma software. L’applicativo può essere diviso in tre blocchi
fondamentali:

Figura 1 - Schema blocchi del software

11


File Manager. Rappresenta l’applicativo che si occupa della
gestione dei files in ingresso al sistema. Il suo ruolo principale è la
gestione della selezione dei file di interesse, mediante dei percorsi
prestabiliti, e l’apertura del relativo viewer per la successiva anteprima e
pubblicazione.

Viewer. Questa sezione permette la visualizzazione dell’anteprima
del file selezionato. Altro compito affidatogli è la possibilità di offrire
un’analisi più approfondita del documento. Da questo blocco si effettua la
pubblicazione del file nel database.

Content Management. Questa sezione lavora “dietro le quinte”. Si
occupa della gestione delle sorgenti, definite in un file di configurazione: i
percorsi delle directory accessibili, le estensioni dei files da visualizzare, i
viewers associati ai tipi di files e le stringhe di connessione, inserimento e
ricerca del DB.

Va sottolineata che questa struttura permette un ampia modularità
e possibilità di sviluppo. Per poter aggiungere moduli viewer, le cartella in
cui cercare i file, i file su cui operare, o cambiare DB o query di ricerca,
sarà sufficiente andare a modificare i file di configurazione.

12


 CLASSI, STRUTTURA E FUNZIONAMENTO

Ogni modulo, sopra descritto, è stato collocato in un namespace
dedicato. Essi sono così definiti

ContentManagement
Questo namespace è costituito dalle seguenti classi:

public static class AssemblyHelper
La sua funzione è quella di trovare gli assembly (le dll) che
implementano i vari viewer utilizzati dal file manager.

public class ContentManager
Si occupa della gestione di tutte le sorgenti di files e la sua
configurazione tramite caricamento del file di configurazione
“contentManager.xml. Inoltre si occupa di identificare l’opportuno
FileHandler per caricare il file selezionato.

public abstract class ContentHandler
public class FileHandler : ContentHandler
Classi per la gestione dei singoli contenuti, in particolare per la
gestione dei singoli file.

public abstract class ContentSource
public class FileSource : ContentSource
Classi per la gestione delle sorgenti di contenuti, in particolare per
la gestione delle directory in un File System da cui prelevare i files gestiti
poi singolarmente con un Content Handler o più specificatamente un File
Handler.

DummyCompany.SomeControls
È la libreria che contiene il visualizzatore e gestiore di files CAD. È
implementato in un assembly diverso da quello di tutta l’infrastruttura per

13


dimostrare il funzionamento del sistema basato su librerie caricate e
configurate dinamicamente.

public class DWGViewer : UserControl, IFileHandler
E’ il viewer che si occuperà di caricare e visualizzare i files DWG e
DXF. La classe deriva da IFileHandler per permettere di passargli il nome
del file da caricare. I suoi compiti sono molteplici: visualizzare l’anteprima
e la struttura ad albero del disegno, estrarre le informazioni del
documento, crea l’XML di informazioni e si occupa dell’invio dei dati al DB.

FileManager
Rappresenta il nostro applicativo.

static class Program

Si occupa della definizione della funzione Main per il caricamento
del programma.

public partial class FileManagerForm : Form
Richiama la libreria ContentManager per il caricamento del file di
configurazione. Successivamente si occupa della selezione delle cartelle
preimpostate per l’operazione e di visualizzarne il contenuto. Altro compito
di cui si occupa è il caricamento dell’opportuno viewer associato al file
selezionato.

public static class Win32Helper
La funzione della classe è quella di caricare le icone dei file
mediante la libreria shell32.dll di Windows.

14


 FILE DI CONFIGURAZIONE

Tutte le configurazioni della piattaforma applicativa saranno
descritte all’interno di un file XML. All’interno della sua struttura, esso
conterrà campi quali:

• estensione dei files;
• directory da cui accedere ai file da archiviare;
• viewers da caricare;
• stringhe relative l’accesso al DB.

<?xml version=quot;1.0quot; encoding=quot;utf-8quot;?>
<contentManager>
<fileSource>
<description>Cartella DXF</description>
<path>C:Documents and SettingsMarcoDesktopCAD</path>
</fileSource>
nome e percorso delle
<fileSource>
cartelle su cui poter
<description>Cartella Prof</description>
operare
<path>C:</path>
</fileSource>
<fileContent>
<description>content CAD (dxf)</description>
<pattern>w+.dxf</pattern>
<typeInfo>DummyCompany.SomeControls.DWGViewer;DummyCompany.SomeControls.dll</typeInfo>
</fileContent>
<fileContent> estensione valida e viewer con
<description>content CAD (dwg)</description> cui operare sul tipo di file
<pattern>w+.dwg</pattern>
<typeInfo>DummyCompany.SomeControls.DWGViewer; DummyCompany.SomeControls.dll</typeInfo>
</fileContent>
<dataBase>
<connectionString>Data Source=LBSQLEXPRESS; Initial ... </connectionString>
<insertString>INSERT INTO FileTbl (Nome, Estensione, ... </insertString>
<transactionString>select ..., GET_FILESTREAM_TRANSACTION... </transactionString>
</dataBase>
</contentManager> - stringa di connessione al DB
- stringa di inserimento dati
- stringa per la transazione del file nel DB

Figura 2 – Analisi del file di configurazione

15


Il file viene usato per configurare il ContentManager. Per l’esattezza
il file sarà richiamato dal FileManager, ma caricato (quindi letto ed
ispezionato in ogni suo campo) dal ContentManager.
Supponiamo di dover aggiungere un nuovo viewer, per la
visualizzazione di un'altra tipologia di file, basterà andare ad aggiungere i
campi necessari nel file di configurazione nel secondo settore indicato
nella figura precedente.
Analogamente se si vuole aggiungere una nuova cartella
contenente i files da caricare, basterà intervenire nel primo settore
inerente i “FileSource”.
Si evince che immettere nel sistema un file DLL (dynamic-link
library) e aggiungere dei campi in un file di configurazione anche solo
mediante un editor di testo, è una soluzione molto comoda ed efficace.
L’uso dei file DLL è fondamentale, in quanto essi sono caricati
dinamicamente in fase di esecuzione del programma. Tali files verranno
caricati solo se effettivamente necessari. Inoltre, ogni singola libreria può
essere caricata in memoria una sola volta e utilizzata da più programmi,
permettendo di risparmiare le risorse del sistema.

16


 INTERFACCIA GRAFICA

Un altro aspetto d’affrontare è come impostare l’interfaccia utente.
Essa sarà realizzata come dalla figura seguente:

Figura 3 – Interfaccia utente

 ARCHITETTURA DATABASE

Nel nostro caso il database sarà costituito da un'unica tabella, che
rappresenta e descrive l’entità FILE. Gli attributi che costituiscono l’entità
file sono le proprietà del file, il file stesso, le informazioni estratte dal
disegno CAD e le note che l’utente potrà inserire.
Il lavoro è stato sviluppato a fronte di un database contenente
un’unica tabella in quanto l’operazione di pubblicazione è solo un test. Il
database reale è oggetto di un altro lavoro di tesi.
Tornando a parlare delle informazioni estratte del disegno, esse
saranno estratte mediante una scansione di tutti gli elementi di cui è

17


costituito. Tali informazioni saranno opportunamente strutturate all’interno
di un XML.

 STRUTTURA DEL DOCUMENTO DI INDICE IN XML

La scelta di strutturare le informazioni del documento mediante un
XML nasce dalla flessibilità che ne permette il suo utilizzo all’interno delle
più svariate piattaforme, sia sul web che fuori dal web.

Il documento che si verrà a creare conterrà l’informazione seguenti:
• nome del documento originario
• elenco dei layers presenti
• l’elenco dei testi

Andiamo ad analizzare un esempio di documento generato.
Nella prima parte troviamo il prologo del file, e la definizione della
grammatica:

<d:document xmlns:d=quot;documentquot; xmlns:ms=quot;metadataSchemaquot; xmlns:tns=quot;dwgquot;
xmlns:drawing=quot;drawingDocumentquot; xmlns:xs=quot;http://www.w3.org/2001/XMLSchemaquot;>
<ms:metadataSchema>
<ms:importMetadataSchema uri=quot;drawingDocumentquot; />
<ms:schema>
<xs:element name=quot;TextWithLocationquot;>
<xs:complexType>
<xs:sequence>
<xs:element name=quot;Textquot; type=quot;xs:stringquot; />
<xs:element name=quot;Xquot; type=quot;xs:decimalquot; />
<xs:element name=quot;Yquot; type=quot;xs:decimalquot; />
</xs:sequence>
</xs:complexType>
</xs:element>
</ms:schema>
<xs:metadataDef name=quot;drawing:TextWithLocationquot; contentType=quot;drawing:TextWithLocationquot; />
</ms:metadataSchema>

18

Successivamente a questa parte di definizione troviamo i campi di
nostro interesse. Tutti gli elementi sono contraddistinti da un attributo
“type”, da un attributo “instanceID” (univoco per ogni elemento) ed un
eventuale “parentInstanceID” ad indicarne la gerarchia.

<d:value type=quot;drawing:Drawingquot; instanceID=quot;1quot;>C:fileProva.dwg</d:value>
<d:value type=quot;drawing:Layerquot; instanceID=quot;2quot; persistence=quot;CARTIGLIOquot; />
<d:value type=quot;drawing:Layerquot; instanceID=quot;3quot; persistence=quot;LINEA-GROSSAquot; />
<d:value type=quot;drawing:Layerquot; instanceID=quot;4quot; persistence=quot;TESTIquot; />
<d:value type=quot;drawing:Layerquot; instanceID=quot;5quot; persistence=quot;TITOLIquot; />
<d:value type=quot;drawing:Layerquot; instanceID=quot;6quot; persistence=quot;STANDARDquot; />
<d:value type=quot;drawing:Layerquot; instanceID=quot;7quot; persistence=quot;LINEA-MEDIAquot; />
<d:value type=quot;drawing:Layerquot; instanceID=quot;8quot; persistence=quot;QUOTEquot; />
<d:value type=quot;drawing:Layerquot; instanceID=quot;9quot; persistence=quot;LINEA-SOTTILEquot; />
<d:value type=quot;drawing:Layerquot; instanceID=quot;10quot; persistence=quot;TESTO-NORMALEquot; />
<d:value type=quot;drawing:Layerquot; instanceID=quot;11quot; persistence=quot;BORDOquot; />

<d:value type=quot;drawing:Textquot; parentInstanceID=quot;2quot; instanceID=quot;20quot; text=quot;NOME PROGETTO:quot; />
<d:value type=quot;drawing:Textquot; parentInstanceID=quot;2quot; instanceID=quot;21quot; text=quot;File di provaquot; />
<d:value type=quot;drawing:Textquot; parentInstanceID=quot;2quot; instanceID=quot;22quot; text=quot;NON SALDAREquot; />
<d:value type=quot;drawing:Textquot; parentInstanceID=quot;2quot; instanceID=quot;23quot; text=quot;SMUSSARE SPIGOLOquot; />
<d:value type=quot;drawing:Textquot; parentInstanceID=quot;2quot; instanceID=quot;24quot; text=quot;3 di 3quot; />
<d:value type=quot;drawing:Textquot; parentInstanceID=quot;2quot; instanceID=quot;25quot; text=quot;0quot; />

<d:value type=quot;tns:TextWithLocationquot; parentInstanceID=quot;2quot; instanceID=quot;125quot; text=quot;NOME
PROGETTO:quot;>
<tns:persistence>
<tns:textWithLocation>
<tns:Text>NOME PROGETTO:</tns:Text>
<tns:X>1934.3376332199898</tns:X>
<tns:Y>-1718.9174478441248</tns:Y>
</tns:textWithLocation>
</tns:persistence>
</d:value>
<d:value type=quot;tns:TextWithLocationquot; parentInstanceID=quot;2quot; instanceID=quot;126quot; text=quot;File di
provaquot;>
<tns:persistence>
<tns:Text>File di prova</tns:Text>
<tns:X>1993.9061738506914</tns:X>
<tns:Y>-1741.8138893506252</tns:Y>
</tns:persistence>
</d:value>
<d:value type=quot;tns:TextWithLocationquot; parentInstanceID=quot;2quot; instanceID=quot;127quot; text=quot;NON
SALDAREquot;>
<tns:persistence>
<tns:Text>NON SALDARE</tns:Text>
<tns:X>2037.4253141293902</tns:X>
<tns:Y>-1741.8138893506252</tns:Y>
</tns:persistence>
</d:value>

</d:document>

Come si può notare è stata omessa gran parte del documento in
quanto di dimensioni notevoli. Le sezioni scritte mostrano il completo
funzionamento e la struttura che vanno a formare il documento.
Come si nota dall’ispezione precedente, la logica dell’utilizzo
dell’attributo “parentInstanceID” rispetta la gerarchia seguente:

19


Figura 4 – Gerarchia dell’XML

20


3.2 PROGETTAZIONE FISICA

 INTERFACCIA E FUNZIONALITA’

Avviato il programma ci si troverà davanti ad una finestra impostata
nel seguente modo:

Figura 5 – Interfaccia del FileManager

Dalla barra degli strumenti, mediante l’apertura di una ComboBox,
sarà possibile selezionare la cartella cui accedere. Al di sotto della barra ci
sarà una ListView dentro la quale verrà caricato l’elenco dei files su cui si
potrà operare e con il doppio click si selezionerà il file desiderato. Per
ultima troviamo la sezione riservata ai viewers. Essa, realizzata mediante
un UserControl, sarà suddivisa in due parti: la prima per la visualizzazione
del documento, la seconda per la parte riguardante la pubblicazione (i dati
estratti ed il pulsante per l’invio di questi ultimi).
Il tutto sarà reso adattabile grazie all’uso degli SplitContainer, che
permetteranno il ridimensionamento dei vari moduli e sezioni.

Nel caso specifico del nostro viewer per i files CAD, la parte relativa
alla visualizzazione del documento conterrà una struttura ad albero dei

21


files nella quale verranno messi in evidenza i layers e i testi. Questi ultimi
mediante doppio-click potranno essere resi visibili e/o invisibili
nell’anteprima del documento. (vd. Figura 7 – il viewer CAD)

Il disegno potrà essere ingrandito o rimpicciolito mediante la
rotellina del mouse. Tramite il doppio-click esso potrà essere centrato
all’interno dell’area di visualizzazione.
La sezione riguardante la pubblicazione si presenterà con un
TextBox all’interno del quale verrà riportato l’XML del file analizzato. Sotto
troviamo un campo per la scrittura di eventuali note da inserire. Per ultimi
ci saranno una barra di progresso e un pulsante per la pubblicazione.
Cliccando sul pulsante verranno inviati tutti i dati nel database. La
progressione della barra indicherà lo stato di tale operazione.

Figura 6 – il viewer CAD (parte 1, 2, 3)

1.

22


2.

3.

23


 REALIZZAZIONE DATABASE

Come precedentemente evidenziato, il DB che denomineremo
StoreFile sarà costituito da un'unica tabella. La tabella che chiameremo
FileTbl sarà così impostata:

Figura 7 – Settaggi tabelle

IdFile, definito come chiave primaria, sarà impostato nella voce
“Identity Specification” con il valore “yes” affinché esso venga auto
incrementato e gestito direttamente dal DBMS. Non potrà essere
ammesso il valore NULL in quanto chiave primaria della tabella.

Nome, sarà definito di tipo nvarchar(256). Esso conterrà solamente
il nome del file (non tutto il suo percorso). Anch’esso è stato settato
affinché non sia ammesso un valore NULL, in quanto il nome è una
proprietà intrinseca dei files.

Estensione, impostato nel medesimo modo del nome gli verrà
solamente limitata la lunghezza dei caratteri ammessi. Il perché non sia
ammesso, anche qui, il valore NULL è analogo al discorso fatto per
l’attributo Nome.

Dimensione, differisce dall’impostazioni poste per i due attributi
precedenti solamente per il contenuto che gli sarà dato. Conterrà solo

24


numeri interi (quindi un numero puro) indicanti il numero di byte di cui è
costituito il file in questione.

FileOriginale, sarà definito di tipo varbinary(MAX) ossia dati binari
a lunghezza variabile che superano gli 8000 byte. È stato impostato in
questo modo per poter usare la funzionalità specifica di SQL Server 2008
dei FILESTREAM che implementa la gestione di Stream come elemento
partecipante ad una transazione SQL . Impostando questo attributo i dati
vengono memorizzati su file system, quindi beneficiano della sua rapida
capacità di streaming e capacità di stoccaggio. Va sottolineato che il tutto
é accessibile e gestibile direttamente all'interno del contesto del database
e che si necessita di un file system di tipo NTFS.
Come precedentemente sottolineato, i singoli file memorizzati in
una colonna FILESTREAM non possono essere aperti direttamente dal
file system NTFS, possono essere manipolati solo come parte di una
transazione di SQL Server. Da prima è stato settato in modo che sia
ammesso il valore NULL, in quanto nell’esecuzione del programma verrà
prima eseguita la select di inserimento degli altri campi. Solo
successivamente ad essa, ed ad un recupero dell’IdFile appena inserito, si
effettua la transaction del file. Notando un incompatibilità fra il valore
NULL e il campo FILESTREAM, si è optato per inserire da subito un
valore di default pari a zero. Vien da se che è stata rimossa la ammissione
del NULL.

Contenuto, sarà definito di tipo XML in quanto dovrà racchiudere il
documento XML creato dalla lettura del file. Sarà la rappresentazione del
disegno in struttura XML. Anch’esso non ammette valore NULL in quanto
ritenuto campo fondamentale.

Note, è un campo di tipo nvarchar(MAX), che conterrà gli eventuali
appunti che l’utente vorrà inserire. A differenza degli altri attributi esso

25


ammette valore NULL in quanto non è un attributo fondamentale
dell’elemento FILE.

Ritengo necessario tornare a parlare del FILESTREAM in quanto
per poter usufruire delle sue caratteristiche, oltre ad un file system di tipo
NTFS, è necessario attivare tale funzione all’interno del DBMS. Per far ciò
bisognerà lanciare una query di comando dal SQL Server Management
Studio:

EXEC sp_configure filestream_access_level, 2
RECONFIGURE

Questa istruzione permette di abilitare il FILESTREAM per
l’accesso T-SQL, per il flusso input/output ma non permette a client remoti
di accedere allo stream.
Per far accedere anche i client remoti è sufficiente rieseguire la
query precedente, sostituendo al valore 2 il 3. Specifico tutto ciò in quanto
può capitare che configurando il SQL Server dalla finestra di proprietà,
esso non mantenga i cambiamenti.

 COMMENTO DEL CODICE

Questa sezione andrà ad occuparsi della descrizione degli aspetti
cruciali e salienti della nostra piattaforma software.
I punti che andremo ad analizzare sono i seguenti:
• lettura del file di configurazione
• caricamento del viewer CAD
• caricamento e scansione degli elementi del disegno
• invio dei dati al DB

- Lettura del file di configurazione

La lettura del file di configurazione viene lanciata dal
FileManagerForm, che passa la stringa del file di configurazione al
ContentManager

26


public static ContentManager CreateInstance( string configFilePath )
{
ContentManager cm = new ContentManager();

XDocument x = XDocument.Load( configFilePath );

XElement contentManager = x.Element( quot;contentManagerquot; );

List<FileHandler> fileContents = new List<FileHandler>();
foreach( XElement fileContentElement in contentManager.Elements( quot;fileContentquot; ) )
{
XElement patternElement = fileContentElement.Element( quot;patternquot; );

XElement descriptionElement = fileContentElement.Element( quot;descriptionquot; );
XElement typeInfoElement = fileContentElement.Element( quot;typeInfoquot; );

fileContents.Add(
new FileHandler( patternElement.Value, descriptionElement.Value,
typeInfoElement.Value ) );
}
cm._fileContentHandlers = fileContents.ToArray();

List<FileSource> fileSources = new List<FileSource>();
foreach( XElement fileSourceElement in contentManager.Elements( quot;fileSourcequot; ) )
{
XElement pathElement = fileSourceElement.Element( quot;pathquot; );

XElement descriptionElement = fileSourceElement.Element( quot;descriptionquot; );

fileSources.Add(
new FileSource( pathElement.Value, descriptionElement.Value ) );
}
cm._fileSources = fileSources.ToArray();

XElement dataBase = contentManager.Element( quot;dataBasequot; );
if( dataBase != null )
{
cm._DB_ConnectionString = dataBase.Element( quot;connectionStringquot; ).Value;
cm._DB_InsertString = dataBase.Element( quot;insertStringquot; ).Value;
cm._DB_TransactionString = dataBase.Element( quot;transactionStringquot; ).Value;
}

_istance = cm;
return cm;
}

Si può notare da prima il caricamento del documento XML che crea
l’oggetto XDocument. Successivamente si passa alla lettura del primo
elemento denominato “contentManager”. Di seguito vengono letti tutti gli
elementi “fileContent” ed i suoi sotto elementi, che andranno a popolare
una lista di FileHandler.
Il medesimo trattamento va applicato agli elementi e sottoelementi
di “fileSource”, che anch’essi popoleranno una lista di FileSource.
L’ultima parte si occupa del caricamento delle stringhe per il DB.

- Caricamento del viewer CAD

Il caricamento del viewer CAD viene lanciato dal FileManager,
facendo doppio click sul file presente all’interno del ListView.

27


listView1.DoubleClick +=
delegate( object sender, EventArgs ea )
{
this.Cursor = Cursors.WaitCursor;
if( listView1.SelectedItems.Count != 1 )
return;
splitContainer1.Panel2.Controls.Clear();
FileInfo fileInfo = (FileInfo)listView1.SelectedItems[0].Tag;

FileHandler ph = cm.ResolveFromFile( fileInfo.Name );
if( ph == null )
return;

IContentHandler ch = ph.CreateFromFile( fileInfo.FullName );

if( ch is Control )
{
Control c = (Control)ch;
c.Dock = DockStyle.Fill;
splitContainer1.Panel2.Controls.Add( c );
}
else
{
MessageBox.Show( quot;Non è possibile visualizzare questo documentoquot; );
}
this.Cursor = Cursors.Arrow;
};

La funzione ottiene l’oggetto FileInfo del file precedentemente
selezionato e passa il suo nome alla funzione ResolveFromFile (del
ContentManager) che restituisce un FileHandler. Questa restituzione sarà
diversa da NULL nel caso in cui identifichi un viewer che rispetta il pattern
associato. Viene richiamata la funzione CreateFromFile, appartenente al
FileHandler restituito, che si occupa di creare un’istanza del nostro viewer
e di passargli il nome completo del file da visualizzare. A questo punto
verrà associato il viewer appena creato alla sua sezione dedicata
(splitContainer1.Panel2).

- Caricamento e scansione degli elementi del disegno

Il caricamento e la scansione degli elementi del disegno, sono
eseguiti all’interno della funzione LoadFrom. Nella prima parte viene
caricato, tramite la funzione CreateImageByExtension o la funzione
LoadFromFile appartenente alla libreria CADImport, l’oggetto CADImage.
Esso sarà condiviso per tutte le funzioni della classe DWGViewer. Il
blocco successivo delle istruzioni calcola lo _zoomFactor, per visualizzare
il disegno all’interno dell’area dedicata.

28


void ContentManagement.IFileHandler.LoadFrom( string filename )
{
_filename = filename;
if( filename == null ) return;

if( disegno != null )
{
disegno.Dispose();
disegno = null;
}
this.disegno = CADImage.CreateImageByExtension( filename );
if( this.disegno is CADRasterImage )
(this.disegno as CADRasterImage).Control = this.drawingPictureBox;

if( this.disegno != null )
{
if( CADConst.IsWebPath( filename ) )
this.disegno.LoadFromWeb( filename );
else
disegno.LoadFromFile( filename );
}

double rapportoH = ((double)drawingPictureBox.Height / disegno.AbsHeight);
double rapportoW = ((double)drawingPictureBox.Width / disegno.AbsWidth);
_zoomFactor = rapportoH >= rapportoW ? rapportoW : rapportoH;
_leftX = 0;
_leftY = 0;

TreeNode treenode = new TreeNode( filename );
treenode.ImageIndex = 0;
treenode.SelectedImageIndex = 0;
drawingTree.Nodes.Add( treenode );

TreeNode Nlayer = new TreeNode( quot;Layersquot; );
treenode.Nodes.Add( Nlayer );
Nlayer.ForeColor = Color.Blue;
for( int i = 0; i < disegno.LayersCount; i++ )
{
string layerNome = disegno.GetLayerName( i );
TreeNode ultimo = new TreeNode( layerNome );
ultimo.Tag = i;
Nlayer.Nodes.Add( ultimo );
Nlayer.LastNode.ForeColor = disegno.GetLayerColor( i );
if( disegno.GetLayerVisible( i ) == true )
{
ultimo.ImageIndex = 3;
ultimo.SelectedImageIndex = 3;
}
else
{
ultimo.ImageIndex = 2;
ultimo.SelectedImageIndex = 2;
}

CADEntityCollection entities = disegno.Converter.GetSection(
ConvSection.Entities ).Entities;
TreeNode NTexts = new TreeNode( quot;Textsquot; );
int c = 0;
for( int z = 0; z < entities.Count; z++ )
{
CADEntity o = entities[z];
if( o is CADText && o.Layer.Name == disegno.GetLayerName( i ) )
{
c++;
CADText text = (CADText)o;
TreeNode newText = new TreeNode( text.Text );
newText.SelectedImageIndex = 1;
newText.ImageIndex = 1;
NTexts.Nodes.Add( newText );
}
}
NTexts.Text = quot;Texts (quot; + c + quot;)quot;;
if( NTexts.Nodes.Count > 0 )
ultimo.Nodes.Add( NTexts );
}

Redraw();

GenerateInstanceDocument();
}

29


La parte successiva ai blocchi precedenti serve per popolare il
TreeView. Si parte creando il primo nodo (root dell’albero) contenente il
nome del file, di seguito viene creato il nodo “Layers” che conterrà i nomi
dei layers presenti nel documento. Essi saranno estratti dalla funzione
GetLayerName. Ad ogni nodo layer contentente del testo verrà associato il
nodo “Texts”, il quale a sua volta conterrà l’elenco dei testi appartenenti a
quel layer. Per far ciò si passano in rassegna tutti gli elementi del disegno
CAD, prelevandone solo quelli inerenti al layer corrente.
A tal punto si disegna il documento all’interno dell’apposita
PictureBox, e sucessivamente si genera il documento XML.

- Invio dei dati al DB

La parte di inserimento dei dati nel DB viene lanciata dall’evento
click del pulsante PubblicaButton.
Come prima cosa viene prelevata la stringa di connessione dal file
di configurazione, e successivamente quella relativa all’inserimento dei
dati. Su quest’ultima andremo ad intervenire, mediante l’oggetto
StringBuilder, sostituendo le parole chiave con i rispettivi campi. Si noti
che nel campo FileOriginale viene assegnato un valore di default pari a
zero in modo da creare un FILESTREAM su disco. Il verò inserimento del
file sarà eseguito tramite una transaction.
Assieme alla query di insert, viene lanciata una select per ottenere
l’ID della riga appena inserita.

Mediante l’uso dell’ID appena ottenuto viene generata una select
per avviare la transaction. Da prima effettuiamo l’accesso in scrittura al
FILESTREAM sul DB, e successivamente si apre e si effettua la lettura del
file originale che viene trasferito a blocchi all’interno del FILESTREAM.
Nelle ultime due righe viene conclusa la transaction e chiusa la
connessione con il DB.

30


private void PubblicaButton_Click( object sender, EventArgs e )
{
string note = textBox2.Text;

string zConnectionString = ContentManager.Istance.DB_ConnectionString;
SqlConnection zConnection = new SqlConnection( zConnectionString );
StringBuilder command = new StringBuilder( ContentManager.Istance.DB_InsertString );
FileInfo fileinfo = new FileInfo( _filename );
command.Replace( quot;@nomequot;, fileinfo.Name );
command.Replace( quot;@estensionequot;, fileinfo.Extension );
command.Replace( quot;@dimensionequot;, fileinfo.Length.ToString() );
command.Replace( quot;@notequot;, note );
command.Replace( quot;@contenutoquot;, _contenuto );
SqlCommand zCommand = new SqlCommand( command.ToString(), zConnection );
Int32 newID = 0;
zConnection.Open();
object ret = zCommand.ExecuteScalar();
if( ret != null )
newID = (int)ret;

// blocco per la transaction FILETREAM
{
SqlCommand Fcommand = new SqlCommand( quot;quot;, zConnection );
StringBuilder FFcommand = new StringBuilder(
ContentManager.Istance.DB_TransactionString );
FFcommand.Replace( quot;@idquot;, newID.ToString() );
Fcommand.CommandText = FFcommand.ToString();
SqlTransaction tran = zConnection.BeginTransaction(
System.Data.IsolationLevel.ReadCommitted );
Fcommand.Transaction = tran;

using( SqlDataReader reader = Fcommand.ExecuteReader() )
{
while( reader.Read() )
{
// Get the pointer for file
string path = reader.GetString( 0 );
byte[] transactionContext = reader.GetSqlBytes( 1 ).Buffer;

SqlFileStream fileStream = new SqlFileStream( path,
(byte[])reader.GetValue( 1 ),
FileAccess.ReadWrite,
FileOptions.SequentialScan, 0 );

fileStream.Seek( 0, SeekOrigin.Begin );
fileStream.SetLength( 0 );

// scrittura del file ...
using( BinaryReader br = new BinaryReader(
new FileStream( fileinfo.FullName, FileMode.Open ) )
)
{
// inizializza contatore
long totalWrite = 0;
byte[] buffer = new byte[4096];
do
{
// modifica la progressbar
progressBar1.Value = (int)(
(100 * totalWrite) / fileinfo.Length);
int count = br.Read(
buffer, 0, buffer.Length );
if( count > 0 )
{
fileStream.Write(buffer, 0, count);
}
else
{
break;
}
// incrementa contatore
totalWrite += count;
} while( true );
}

fileStream.Close();
}
}
tran.Commit();
}

zConnection.Close();
}

31


 TEST

Per poter verificare il funzionamento previsto del sistema si è
provveduto alla realizzazione di un’interfaccia di collaudo. Esso consiste in
una Form richiamabile direttamente da un pulsante in alto a destra della
ToolStrip.
Si è voluto simulare il funzionamento finale desiderato (scopo della
tesi), ovvero quello di cercare una parola chiave contenuta all’interno di
uno dei campi testo presenti nei documenti archiviati.

Per ottenere questo risultato è stata realizzata una “doppia query”:
una per la selezione dei campi di interesse dell’elemento “File”, ed una
annidata per la ricerca all’interno del campo XML (colonna “Contenuto”
della FileTbl) attraverso una XQuery.
Tale query è stata associata ad un SqlDataAdapter, con il suo
relativo SqlConnection. Da questo è stato realizzato il DataSet che
conterrà il risultato della query in memoria. Per visualizzarlo è stato creato
un DataGridView, al quale è stato associato il DataSet e la relativa tabella
da visualizzare.

Per verificare l’effettivo salvataggio del file originale si è scelto di
associare al doppio click del DataGridView il salvataggio del file
selezionato sul disco e relativa apertura. Per effettuare il salvataggio del
file sul disco è stata eseguita una select e relativa transaction, per
ottenere il FILESTREAM desiderato. L’apertura è fatta mediante il
programma di default associata da Windows per quella tipologia di files.

32


Figura 8 – Interfaccia della finestra di test

33

CONCLUSIONI

Capitolo 4
CONCLUSIONI

È possibile affermare, che i requisiti e le specifiche fissati all’inizio del
progetto sono stati rispettati, e concludere quindi che gli obiettivi prefissati
sono stati raggiunti.
Dai files di partenza, contenuti in percorsi predefiniti, è possibile
estrarre le informazioni contenute al loro interno. Presi dalle cartelle
indicate nel file XML di configurazione, i files possono essere visualizzati
uno ad uno. Se ne estraggono le informazioni contenute (strutturate
opportunamente all’interno di un file XML) e vi si inseriscono le eventuali
note. Cliccando sul tasto “Pubblica” si effettua l’inserimento di tali dati e
del file stesso nel database.
Creata la base dati, essa è a disposizione per ogni tipo di
interrogazione.
Per quanto riguarda invece il lavoro svolto, gli elementi che hanno
richiesto una maggiore attenzione e tempo sono state la fase di
progettazione iniziale della struttura del programma, la realizzazione della
parte inerente alla manipolazione dei files CAD mediante l’uso della
libreria CADImport e il salvataggio dei file nel database mediante
funzionalità FILESTRAM.
Il progetto realizzato è nello stato di prototipo; dispone delle funzioni
base di cui necessita, in quanto questo lavoro si inserisce in uno studio di
fattibilità per l’azienda cui è destinato. Nonostante ciò, l’architettura con la

34

CONCLUSIONI

quale è stato realizzato il software, conferisce una struttura solida e la
possibilità di ulteriori sviluppi.
La prosecuzione naturale di questo lavoro è, prima di tutto, la
realizzazione dei altri “content handler” per la gestione di altri tipi di files e
l’implementazione di altri “content source” per la gestione di altri canali da
cui ricevere files (come ad esempio un “Mail Source” per la ricezione di
files via protocollo POP3).
A mio avviso è stato molto interessante veder come un programma
semplice per aprire un file diventi così articolato per poter ottenere una
struttura modulare. La parte di ispezione delle informazioni
nei progetti CAD mi è sembrata relativamente semplice, pensavo
potesse risultare più ostica del previsto. Affermo ciò
in quanto credevo che usufruire di una libreria creata da terzi potesse
creare maggiori complicazioni.
Anche per quanto concerne l'uso dei FILESTREAM è risultato più
arduo configurare correttamente il sistema che eseguire la transazione
stessa.
Nel complesso del lavoro svolto mi ritengo soddisfatto dei risultati
ottenuti e di tutto ciò che ne è derivato.

35

ABBREVIAZIONI USATE

Appendice A
ABBREVIAZIONI USATE

Computer Aided Design
CAD

Common Language Infrastructure
CLI

DataBase
DB

DataBase Managament System
DBMS

Dynamic-Link Library
DLL

DraWinG
DWG

Drawing eXhange Format
DXF

Modello Entità-Relazioni
E/R

Hyper Text Mark-Up Language
HTML

IDentificatore
ID

Integrated Development Environment
IDE

International Standard Organization
ISO

New Technology File System
NTFS

Open Database Connectivity
ODBC

Structured Query Language
SQL

Tabular Data Stream
TDS

36

ABBREVIAZIONI USATE

Transact-SQL
T-SQL

eXtensible Markup Language
XML

37

ELENCO DELLE IMMAGINI

Appendice B
ELENCO DELLE IMMAGINI

Figura 1 - Schema blocchi del software ________________________ 11

Figura 2 - Analisi del file di configurazione_______________________ 15

Figura 3 - Interfaccia utente _________________________________ 17

Figura 4 - Gerarchia dell’XML ________________________________ 20

Figura 5 - Interfaccia FileManager _____________________________ 21

Figura 6 - il viewer CAD (parte 1)______________________________ 22

Figura 6 - il viewer CAD (parte 2,3) ____________________________ 23

Figura 7 - Settaggi tabelle ___________________________________ 24

Figura 8 - Interfaccia della finestra di test _______________________ 33

38

BIBLIOGRAFIA

Appendice C
BIBLIOGRAFIA

1. http://community.ugiss.org/blogs/abenedetti/archive/2008/07/08/sql-

2008-filestream-che-non-si-riesce-ad-abilitare.aspx abilitazione del

FILESTREAM

2. http://www.codeplex.com/SQLSrvEngine/Wiki/View.aspx?title=FileS

treamEnable&referringTitle=Home settaggi del FILESTREAM

3. http://msdn.microsoft.com/en-us/library/cc716724.aspx

FILESTREAM in SQL Server 2008

4. http://msdn.microsoft.com/it-it/library/cc645585.aspx procedura di

creazione di un DB abilitato per FILESTREAM

5. http://blogs.msdn.com/rdoherty/archive/2007/10/18/handling-null-

instances-of-varbinary-max-filestream-columns.aspx valore NULL

per i campi abilitati al FILESTREAM

6. http://www.cadsofttools.com/ download libreria CAD e sue

documentazioni

7. http://media.aspitalia.com/screencast/LINQ-to-XML-

introduzione.media creazione e gestione documenti XML

39

BIBLIOGRAFIA

8. http://blog.shareoffice.it/emanuele/archive/2008/10/15/9770.aspx

lettura di un file XML

9. http://community.visual-

basic.it/lucianob/archive/2007/06/24/19728.aspx icone di Windows

da associare ai files

10. http://web.tiscali.it/Didattica/vb/dxf.htm caratteristiche dei files .dxf

11. http://it.wikipedia.org/wiki/AutoCAD_DWG caratteristiche dei files

.dwg

12. http://msdn.microsoft.com/en-us/library/default.aspx guida Microsoft

per il frame work .Net

13. http://www.dotnethell.it/ forum sulla programmazione

14. http://support.microsoft.com/kb/813450/it controllo degli user control

40

Tesi Marco Ventura

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (18)

Similaire à Tesi Marco Ventura

Similaire à Tesi Marco Ventura (20)

Tesi Marco Ventura