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 11.1 PREFAZIONE 1

Capitolo 2 ANALISI 32.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# 62.1.3 CAD Import.Net 72.1.4 SQL: Structured Query Language 7 MICROSOFT SQL SERVER 72.1.5 XML: eXtensible Markup Language 8 L’XML Schema Definition 9

2.2 RACCOLTA DEI REQUISITI 10

Capitolo 3 REALIZZAZIONE DEL SOFTWARE 113.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

1

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

INTRODUZIONE

2

è 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.

ANALISI

3

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

ANALISI

4

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.

ANALISI

5

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

ANALISI

6

oggetti

C#

, 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.

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 "primitivi" 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 "spazi di nomi". 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 "Forms", System.Xml per l'elaborazione di XML e

System.Data per l'accesso alle basi dati.

Un ulteriore livello di organizzazione è costituito dagli "assembly",

che può essere un singolo file od una serie di file collegati fra di loro ed

avere al suo interno diversi spazi di nomi.

ANALISI

7

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.

ANALISI

8

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 "Tabular Data Stream" (TDS). SQL Server supporta anche

"Open Database Connectivity" (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;

ANALISI

9

• 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="1.0"

encoding="ISO-8859-1"?>;

• 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.

ANALISI

10

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.

REALIZZAZIONE DEL SOFTWARE

11

Capitolo 3

REALIZZAZIONE DEL SOFTWARE

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

REALIZZAZIONE DEL SOFTWARE

12

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.

REALIZZAZIONE DEL SOFTWARE

13

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

REALIZZAZIONE DEL SOFTWARE

14

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.

REALIZZAZIONE DEL SOFTWARE

15

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="1.0" encoding="utf-8"?>

<contentManager> <fileSource> <description>Cartella DXF</description> <path>C:\Documents and Settings\Marco\Desktop\CAD</path> </fileSource> <fileSource> <description>Cartella Prof</description> <path>C:\</path> </fileSource> <fileContent> <description>content CAD (dxf)</description> <pattern>\w+\.dxf</pattern> <typeInfo>DummyCompany.SomeControls.DWGViewer;DummyCompany.SomeControls.dll</typeInfo> </fileContent> <fileContent> <description>content CAD (dwg)</description> <pattern>\w+\.dwg</pattern> <typeInfo>DummyCompany.SomeControls.DWGViewer; DummyCompany.SomeControls.dll</typeInfo> </fileContent> <dataBase> <connectionString>Data Source=LB\SQLEXPRESS; Initial ... </connectionString> <insertString>INSERT INTO FileTbl (Nome, Estensione, ... </insertString> <transactionString>select ..., GET_FILESTREAM_TRANSACTION... </transactionString> </dataBase> </contentManager>

Figura 2 – Analisi del file di configurazione

nome e percorso delle cartelle su cui poter operare

estensione valida e viewer con cui operare sul tipo di file

- stringa di connessione al DB - stringa di inserimento dati - stringa per la transazione del file nel DB

REALIZZAZIONE DEL SOFTWARE

16

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.

REALIZZAZIONE DEL SOFTWARE

17

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 è

REALIZZAZIONE DEL SOFTWARE

18

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="document" xmlns:ms="metadataSchema" xmlns:tns="dwg" xmlns:drawing="drawingDocument" xmlns:xs="http://www.w3.org/2001/XMLSchema"> <ms:metadataSchema> <ms:importMetadataSchema uri="drawingDocument" /> <ms:schema> <xs:element name="TextWithLocation"> <xs:complexType> <xs:sequence> <xs:element name="Text" type="xs:string" /> <xs:element name="X" type="xs:decimal" /> <xs:element name="Y" type="xs:decimal" /> </xs:sequence> </xs:complexType> </xs:element> </ms:schema> <xs:metadataDef name="drawing:TextWithLocation" contentType="drawing:TextWithLocation" /> </ms:metadataSchema>

REALIZZAZIONE DEL SOFTWARE

19

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="drawing:Drawing" instanceID="1">C:\fileProva.dwg</d:value> <d:value type="drawing:Layer" instanceID="2" persistence="CARTIGLIO" /> <d:value type="drawing:Layer" instanceID="3" persistence="LINEA-GROSSA" /> <d:value type="drawing:Layer" instanceID="4" persistence="TESTI" /> <d:value type="drawing:Layer" instanceID="5" persistence="TITOLI" /> <d:value type="drawing:Layer" instanceID="6" persistence="STANDARD" /> <d:value type="drawing:Layer" instanceID="7" persistence="LINEA-MEDIA" /> <d:value type="drawing:Layer" instanceID="8" persistence="QUOTE" /> <d:value type="drawing:Layer" instanceID="9" persistence="LINEA-SOTTILE" /> <d:value type="drawing:Layer" instanceID="10" persistence="TESTO-NORMALE" /> <d:value type="drawing:Layer" instanceID="11" persistence="BORDO" /> <!-- prosegue con tutti gli altri layers del documento --> <d:value type="drawing:Text" parentInstanceID="2" instanceID="20" text="NOME PROGETTO:" /> <d:value type="drawing:Text" parentInstanceID="2" instanceID="21" text="File di prova" /> <d:value type="drawing:Text" parentInstanceID="2" instanceID="22" text="NON SALDARE" /> <d:value type="drawing:Text" parentInstanceID="2" instanceID="23" text="SMUSSARE SPIGOLO" /> <d:value type="drawing:Text" parentInstanceID="2" instanceID="24" text="3 di 3" /> <d:value type="drawing:Text" parentInstanceID="2" instanceID="25" text="0" /> <!-- prosegue con tutti gli altri elementi di testo del disegno --> <d:value type="tns:TextWithLocation" parentInstanceID="2" instanceID="125" text="NOME PROGETTO:"> <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="tns:TextWithLocation" parentInstanceID="2" instanceID="126" text="File di prova"> <tns:persistence> <tns:textWithLocation> <tns:Text>File di prova</tns:Text> <tns:X>1993.9061738506914</tns:X> <tns:Y>-1741.8138893506252</tns:Y> </tns:textWithLocation> </tns:persistence> </d:value> <d:value type="tns:TextWithLocation" parentInstanceID="2" instanceID="127" text="NON SALDARE"> <tns:persistence> <tns:textWithLocation> <tns:Text>NON SALDARE</tns:Text> <tns:X>2037.4253141293902</tns:X> <tns:Y>-1741.8138893506252</tns:Y> </tns:textWithLocation> </tns:persistence> </d:value> <!-- prosegue con tutti gli altri elementi di testo del disegno --> </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:

REALIZZAZIONE DEL SOFTWARE

20

Figura 4 – Gerarchia dell’XML

REALIZZAZIONE DEL SOFTWARE

21

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

REALIZZAZIONE DEL SOFTWARE

22

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.

REALIZZAZIONE DEL SOFTWARE

23

2.

3.

REALIZZAZIONE DEL SOFTWARE

24

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

REALIZZAZIONE DEL SOFTWARE

25

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

REALIZZAZIONE DEL SOFTWARE

26

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

REALIZZAZIONE DEL SOFTWARE

27

public static ContentManager CreateInstance( string configFilePath ) { ContentManager cm = new ContentManager(); XDocument x = XDocument.Load( configFilePath ); XElement contentManager = x.Element( "contentManager" ); List<FileHandler> fileContents = new List<FileHandler>(); foreach( XElement fileContentElement in contentManager.Elements( "fileContent" ) ) { XElement patternElement = fileContentElement.Element( "pattern" ); XElement descriptionElement = fileContentElement.Element( "description" ); XElement typeInfoElement = fileContentElement.Element( "typeInfo" ); 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( "fileSource" ) ) { XElement pathElement = fileSourceElement.Element( "path" ); XElement descriptionElement = fileSourceElement.Element( "description" ); fileSources.Add(

new FileSource( pathElement.Value, descriptionElement.Value ) ); } cm._fileSources = fileSources.ToArray(); XElement dataBase = contentManager.Element( "dataBase" ); if( dataBase != null ) { cm._DB_ConnectionString = dataBase.Element( "connectionString" ).Value; cm._DB_InsertString = dataBase.Element( "insertString" ).Value; cm._DB_TransactionString = dataBase.Element( "transactionString" ).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.

REALIZZAZIONE DEL SOFTWARE

28

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( "Non è possibile visualizzare questo documento" ); } 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.

REALIZZAZIONE DEL SOFTWARE

29

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( "Layers" ); 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( "Texts" ); 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 = "Texts (" + c + ")"; if( NTexts.Nodes.Count > 0 ) ultimo.Nodes.Add( NTexts ); } Redraw(); GenerateInstanceDocument(); }

REALIZZAZIONE DEL SOFTWARE

30

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.

REALIZZAZIONE DEL SOFTWARE

31

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( "@nome", fileinfo.Name ); command.Replace( "@estensione", fileinfo.Extension ); command.Replace( "@dimensione", fileinfo.Length.ToString() ); command.Replace( "@note", note ); command.Replace( "@contenuto", _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( "", zConnection ); StringBuilder FFcommand = new StringBuilder(

ContentManager.Istance.DB_TransactionString ); FFcommand.Replace( "@id", 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(); }

REALIZZAZIONE DEL SOFTWARE

32

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.

REALIZZAZIONE DEL SOFTWARE

33

Figura 8 – Interfaccia della finestra di test

CONCLUSIONI

34

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

CONCLUSIONI

35

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.

ABBREVIAZIONI USATE

36

Appendice A

ABBREVIAZIONI USATE

CAD Computer Aided Design

CLI Common Language Infrastructure

DB DataBase

DBMS DataBase Managament System

DLL Dynamic-Link Library

DWG DraWinG

DXF Drawing eXhange Format

E/R Modello Entità-Relazioni

HTML Hyper Text Mark-Up Language

ID IDentificatore

IDE Integrated Development Environment

ISO International Standard Organization

NTFS New Technology File System

ODBC Open Database Connectivity

SQL Structured Query Language

TDS Tabular Data Stream

ABBREVIAZIONI USATE

37

T-SQL Transact-SQL

XML eXtensible Markup Language

ELENCO DELLE IMMAGINI

38

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

BIBLIOGRAFIA

39

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

BIBLIOGRAFIA

40

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