Newsgroup: it.comp.lang.visual-basic
Titolo: [?] Separatore "sicuro" in file ASCII

Vorrei creare un file ASCII contenente informazioni provenienti da database
in modo che chi riceve il file possa ricreare il database stesso come
struttura e contenuti.
Il problema, non sapendo a priori i contenuti dei campi, è il separatore fra
un'informazione e l'altra che possa essere introdotto e interpretato (da
programmi appositi e dedicati) con la certezza che non è contenuto in
qualche dato, con i pasticci interpretativi che ne possano conseguire.
Ok, potrei creare un separatore strano fatto di più caratteri, ma, per
schizofrenico che possa essere (senza però essere troppo lungo, col rischio
che occupino di più i separatori che i dati da separare) non sarebbe
comunque certo.
La via potrebbe essere quella di usare Chr(0) e poi trattare il file
pseudo-ASCII leggendolo in binario, ma lo lascerei come ultima spiaggia.
Non conosco XLM, ma come fa a passare informazioni con la certezza
dell'univocità delle tags/separatori e i dati?
Rammento un vecchia discussione che compresi (so de coccio!) dopo un tot che
diceva "tag-lunghezza-dati, tag-lunghezza-dati, etc." in modo che nulla in
dati potesse essere frainteso come tag, ma, anche qui, lo lascerei per
ultimo.
Qualche idea, per favore? Grazie.

 Qualche idea, per favore? Grazie.
Sinceramente non mi viene in mente altro, se si vuole avere la CERTEZZA di
non confondere i delimitatori con i dati....
inoltre non ho capito se non *puoi* o se non *vuoi* utilizzare XML?
ciaociao

> Qualche idea, per favore? Grazie.
Ah! un'idea malsana.....
Se il database è tuo (quindi conosci a priori i campi), non potresti pensare
ad un file a lunghezza fissa?
o i dati sono troppi e si avrebbe un filettone da 100Gb? :)
ciaociao

 inoltre non ho capito se non *puoi* o se non *vuoi* utilizzare XML?
Non è che non voglio, è che non lo conosco.
Quello che non voglio è studiarmelo, visto che non ho necessità di usarlo.
Mi farò il mio XMLL :-P

 Qualche idea, per favore? Grazie.
boh... o fai come XML o usi gli apici e li raddoppi come fa VB con le
stringhe.
es:
campo1'campo2
dell''uomo'campo2
termoPilucco

[Marg = 
circa...@inwind.it
 in
c6097e$6e1f6$
1...@ID-193795.news.uni-berlin.de
] ha scritto:

No, deve valere per ogni e sconosciuto/database (diciamo Access e SQL
Server).
L'idea mi è venuta da applicare a ESP0DAMA.
Capita che alcuni utenti debbano mandarmi dei database. Questi, per
contenuti e/o mancata compattazione, possono essere molto grossi, anche
zippati. L'idea era quella di comporre il file ti testo, zipparlo e
inviarlo. Sarà certamente più piccono del database pur compresso e zippato.
Poi in casa con ESP0DAMA, leggendo il file, mi creo database e contenuti, ci
lavoro su e, se il caso, glielo rimando con la stessa tecnica.

 stringhe.
Mi sento molto fantozziano :-P (non con te, sia ben chiaro, ma con XML...)

 ha scritto nel messaggio
news:c608kp$6jp57$1...@ID-174464.news.uni-berlin.de...

Secondo me il metodo piu' semplice soprattutto se il file te lo scrivi a
mano con print o put senza utilizzare ODBC o ADO (che poi e' il metodo che
preferisco) e' di scegliere un carattere (quello che preferisci ma meno e'
frequente nei dati che devi esportare meglio e') e poi lo raddoppi quando lo
scrivi. Per esempio se il tuo carattere e' chr$(100) prima di scrivere il
campo su disco fai un bel
miocampo=replace(miocampo, chr$(100), chr$(100) & chr$(100))
e poi lo scrivi
invece quando scrivi il separatore lo scrivi una sola volta. Cosi' quando
vai a rileggere il file se trovi un solo chr$(100) significa che e' il
separatore invece se e' un doppio chr$(100) vuole dire che e' un dato.
L'unico problema che puoi avere (credo) e' se il carattere che hai scelto e'
il primo carattere del campo (quindi tienine conto)
Ciao
________________________________________________________________________
Fabio
Web : 
http://www.codice.it

A parte qualunque discussione puramente teorica, ma nella pratica, quante
volte credi possa capitare ina combinazione del tipo #§@|£  ?
Io credo che tu possa avere la certezza che non capiti nel 99.9999% dei
casi.
Inoltre anche se i dati occupano 5 byte, zippando il file l'algoritmo di
Huffman (che lavora in coppia con LZ77 nello zip) ti creerà un rapporto di
compressione altissimo (anche un solo bit per identificare la stringa).
Quindi non sono 5^n byte, ma n bit.
bye
-- 
Esistono 10 tipi di persone: chi conosce il binario e chi no.
Gestione Ottica - Gestionale per Ottici e Programmi Gratuiti su:
http://www.nicolaottomano.it

 dei casi.
non dire mai queste cose a lupo.
potrebbe mordere.
-- 
Salutoni
Sergio
per rispondere... togli il group dall'indirizzo

 potrebbe mordere.
Cmq l'idea mia non è male. Statisticamente parlando la ragione è dalla mia.
E' chiaro che in un discorso del tutto teorico io ho torto.
Teoricamente è possibile che io vinca alla lotteria.... ma effettivamente
quante volte può capitarmi una cosa del genere? Capito mi hai? ;-)


 dalla mia. E' chiaro che in un discorso del tutto teorico io ho torto.
Giusto per dare una idea. Se tutti i caratteri avessero uguale probabilità
di apparire in un testo, allora avremmo:
#§@|£ = 5 caratteri quindi
(1/256)^5= 9,094*10^-13=0.0000000000009094 probabilità che appaiano tutti e
5 i caratteri.
Però essendoci migliaia di caratteri in un testo dovremmo moltiplicare
questo valore per il numero di caratteri. Quindi se abbiamo 100000
(centomila!) caratteri allora diventa:
9,094*10^-8    Praticamente una probabilità su cento milioni!!!
Sempre che non abbia sbagliato i calcoli.


 dalla mia.
appunto.
vuoi che ti ricordi cosa succede quando parli di statistica a lupo?


 E' chiaro che in un discorso del tutto teorico io ho torto.
No, hai torto nel discorso pratico, perchè stai sicuro che quella 
combinazione verrà fuori prima di quant pensi appena l'algoritmo sarà 
messo in funzione.
E vedere il programma implodere su sè stesso per questo tipo di 
leggerezze è da sconsiderati ;)
Ciao

 vuoi che ti ricordi cosa succede quando parli di statistica a lupo?
Beh io non posso fornire la certezza matematica che non vi possa essere una
combinazione del genere, ma posso comunque darti una certezza relativa...
In quasi tutto ciò che faccio mi baso su questa frase: "L'unica cosa certa è
che tutto è relativo..."
Era la firma di qualcuno del NG se non erro.


 leggerezze è da sconsiderati ;)
Non implode... puoi stare tranquillo... :-)


 che tutto è relativo..."
La frase da adottare in informatica è una trasposizione della legge di 
murphy: "Ogni casistica DEVE essere considerata".
Ciao

 tipo #§@|£  ?
Se dovesse archiviare i post di questo gruppo in un DB capiterebbe ben due
volte :P
termioPilucco

 Dubito di ciò
Qualcuno lo disse anche in america: "quale probabilità c'è che uno pigli 
un aerero, che passi sopra NY senza essere visto ne fermato, che si 
scontri con un edificio?"
Però è successo ben 2 volte :(
Ciao

 ha scritto nel messaggio
news:c60c1q$6ccih$
3...@ID-184808.news.uni-berlin.de

2 volte su MILIONI di voli fatti ogni anno nel mondo....


 ben due volte :P
LOL


 Però è successo ben 2 volte :(
Probabilità condizionata.
Alla fine della frase va aggiunto "dato che qualcuno ben organizzato intende
farlo e noi non ne siamo al corrente."
termoPilucco

 > qualche dato, con i pasticci interpretativi che ne possano conseguire.
Un'altra idea potrebbe essere quella di ricodificare tutto con un numero
minore di bit (per es. a 7 bit) oppure direttamente in hex (tanto poi devi
zipparlo)
Auguri

 ha scritto nel messaggio
news:c608kp$6jp57$1...@ID-174464.news.uni-berlin.de...
[cut]
Lupo, quello del separatore dei dati e' un problema risalente ai primi anni
dell'informatica e c'e' una soluzione ormai standard, testata ed ultra
sicura.
Leggiti il messaggio di Mino Fabio, sono 50 anni che si fa in quel modo e
nessuno se n'e' mai pentito :-)

 ben due volte :P
Allora aggiungo una piccola modifica:
Nel file crea un Header dove salva una combinazione di 5 caratteri casuale
scelta fra caratteri che non siano numeri e lettere.
In tal caso la combinazione varia da database a database e le probabilità di
beccare proprio quella combinazione diventerebbero una su migliaia di
miliardi....
Lupo facce sapè! :-)


 identificare la stringa). Quindi non sono 5^n byte, ma n bit.
Su questo (non conosco) non discuto.
Credo che me ne strafregherò dei bytes "consumati" per la lunghezza e andrò
con "tag-lunghezza*-dati"
* Magari con un "=" dopo i crt numerici per ridurre al minimo l'indicazione
della lunghezza, pur consumando un "="

 Statisticamente parlando
Ovvero parlando a vanvera (nulla di personale, forse ricorderai un recente
topic sulla statistica, per me il contrario della scienza, quindi
l'affermazione dell'insicurezza...)

 vuoi che ti ricordi cosa succede quando parli di statistica a lupo?
Ecco!
Lupo.peggio.di.Murphy


mmmm....va a finire che prima o poi mi toccherà di utilizzarlo sto
espOdama.... :-P
ciaociao

 Non implode... puoi stare tranquillo... :-)
Non implode su di te, ma, quando dovesse accadere, su di me. Stai sicuro.

 In tal caso la combinazione varia da database a database
Perchč?

[Drizzt = 
circa_d...@libero.it
 in c60com$lc6$
1...@news.ngi.it
] ha scritto:

Probabilmente (sic) hai ragione, ma io (tu no?) sono spesso (no, non sempre)
convinto che tutti coloro che hanno pensato prima di me (o altri,
ovviamente), non le abbiano pensate tutte. Dici che sono (/siamo)
presuntuoso (/i)? No, semplicemente realista, storicamente realista.

 realista.
quindi realisticamente presuntuoso, si potrebbe dire. anche perchč, male che
vada, siamo nani sulle spalle di giganti.


 espOdama.... :-P
Ora vedo se ti ho messo nei credits. Me tapino, ti ci tolgo in un momento
:-P

 male che vada, siamo nani sulle spalle di giganti.
Sì, relativamente vero. In assoluto, invece, anche i giganti sbagliano o
possono "non pensarle tutte".
Si fermerebbe il mondo se così non fosse.
Io non voglio cambiare il mondo, ma amo assimilare, anche quando le mie
pensate non conducono ad altro che non sia "già pensato".
Se poi guadagno un bit (ben sapendo che i giganti ben si prodigano a come
perderlo) ecco, ho fatto meglio.


noooo! non farlo! ;-)
Se vuoi ti gestisco la localizzazione, così diventerà ESP1DAMA!
ciaociao

[Marg = 
circa...@inwind.it
 in
c60fqp$6edhs$
1...@ID-193795.news.uni-berlin.de
] ha scritto:

Non c'eri e la localizzazione è solo IT. Se Bill mi chiede la EN, ti farò un
fischio :-P
Perchè 1 e non P? Stra :-P

Mi stavo rollando una paglia quando fui interrotto da termoPilucco
che diceva:

probabilità ufficiosa.
La frase precedente va letta come "dato che qualcuno ben organizzato intende
farlo e noi, pur sapendolo, non facciamo nulla"
/me che torna al lurking
aloha
-- 
Stefano Zamboni - 
zam...@freemail.it
Legge di Tussman:
Niente è inevitabile come un errore il cui momento è giunto.

 Se vuoi ti gestisco la localizzazione, così diventerà ESP1DAMA!
ESPIDAMA?
termoPilucco

 presuntuoso (/i)? No, semplicemente realista, storicamente realista.
No, non hai capito il senso del messaggio. Non dicevo che e' male cercare
alternative, anzi! Io sono sempre il primo a farlo:-)
Pero':
1) Tu hai chiesto come si puo' fare per avere un separatore "sicuro", non
come si puo' fare per averne uno "innovativo":-)
2) Nessuno ti impedisce di trovare un metodo migliore. Pero' sono
ragionevolmente sicuro che difficilmente troverai qualcosa di meno pesante
in termini di uso di memoria e potenza di calcolo. Pensa alla differenza
nell'avere un tag composto da una sola lettera o di avere un tag composto da
"TAG-len dati-CRC"...
Spero di essermi fatto capire :-)

 termoPilucco.tardivo :-P (e intanto Marg gongola)

 Perchè 1 e non P? Stra :-P
LOL
ciaociao

 Spero di essermi fatto capire :-)
Certo e sono d'accordo. Ma, prima di fumarmi la testa, potrei decidere che
un byte in piů o in meno fa poca differenza... (anche se questo era uno
degli scopi)

 casi.
sempre che il db non contenga i pensierini di lupo nei confronti di ms, nel
qual caso l'unicode dei goti di asterix e' troppo limitato.

 vuoi che ti ricordi cosa succede quando parli di statistica a lupo?
<flautato>
    cosa ?
</>

 Però è successo ben 2 volte :(
non vale. lo sapevano prima :P.amaro

 Non implode su di te, ma, quando dovesse accadere, su di me. Stai sicuro.
ehm, in italiano puo' implodere solo su se stesso :)

 Nel file crea un Header dove salva una combinazione di 5 caratteri casuale
p.e. "iclvb", e esclude quei record dal db :P


Perche' non usi il CSV????
Separi i campi con una virgola e li delimiti con il doppio apice,
qualora nel valore tu depositi nel file ci fosse un doppio apice, lo
raddoppi.
Ciao!
Luca

 vada, siamo nani sulle spalle di giganti.
dipende. alcuni politici sono nani sulle palle di noiartri.

 questo era uno degli scopi)
Umm umm e se prendi spunto dall'SQL ?
cioe' nella testa del file ascii metti l'sql che crea la tabella (insieme al
DB).
poi il corpo del file non sara' null'altro che un file,
(se vuoi sprecare byte) :
XXXXYYYYYYYY......XXXXYYYY...
XXXX = Numero Esadecimale rappresentante la lunghezza del Campo
YYYYYYYY...dati
Cosi' sprechi 4byte = FFFF = "65535" di lunghezza massima per un campo
e poi hai i tuoi dati come ti pare, tanto inizio e fine ti sono noti.
NB: 4byte a campo e' parecchio...
NB2: Il file lo leggi in binario logicamente
(Se non vuoi sprecare byte)
"YYYYYY","","YYYY"
Y = dati
" = delimitatore
, = separatore... pero' la sequenza "," e' comune purtroppo ... quindi
dovresti fare come il Php che il " non finale lo trasforma in  "/
Quindi :  fantozzi disse : "La corazzata..."
diventa :  "fantozzi disse : "/La corazzata..."/"
conta che la stringa finisce sempre con " seguito da nulla e che tra una
stringa e un altra non si potra' mai verificare il caso  "/   quindi e'
sicuro !
Cosa ne pensi ?
-- 
-Gigio@Work(?)-

 sbagliano o possono "non pensarle tutte".
ehm...
il senso della frase è assolutamente questo.
tu (il "tu" è da intendersi come "impersonale") magari non sei in grado di
pensare tutte le cose che hanno pensato loro, ma sapendo già che cosa loro
hanno pensato è facile che possa aggiungere una pensata in più.


javalab ha scritto:

Allora quando si dice "implode su se stesso" è una ripetizione :)
Ciao

 2 volte su MILIONI di voli fatti ogni anno nel mondo....
Intanto è successo.
Ciao

 ha scritto

per essere precisi, e' un'implosione :))

[javalab = 
circa...@labrador.ca
 in
c60igd$6e5hr$
1...@ID-51318.news.uni-berlin.de
] ha scritto:

Hai ragione, ma se un'esplosione puň far male a chi sta nel paraggi,
un'implosione anche, forse di piů. I buchi neri insegnano.

[Lupo = 
circa_LupoOrm...@libero.it
 in
c608kp$6jp57$
1...@ID-174464.news.uni-berlin.de
] ha scritto:
...
Sto ipotizzando questa "soluzione":
Ogni riga vuota (interlinea) indica che la seguente è una riga di nuova
testata. La testata sarà completamente descritta in una sola riga.
La riga di testata indica la tipologia delle righe che seguono, a piacere
dello specifica applicativo.
Ogni tag (di testata o di riga) è numerata progressivamente da 1 (numerico)
e viene seguita da un carattere (o più identici) (ad esclusione di 0-9 e :)
che indica i crt di fine del dato e viene conclusa con ":" (non numerico).
Evidentemente il carattere di fine dato viene scelto fra tutto il set ASCII
(ad esclusione, come detto, di 0-9 e :) in modo che non sia compreso nel
dato che la tag esprime. Se tutti i crt ASCII sono compresi nel dato si
ricicla con un doppio carattere, triplo, etc. Ovviamente si può prevedere un
carattere default (da applicarsi se fra la tag numerica e : non c'è alcun
carattere. Il carattere di default dovrà comunque essere esplicitamente
presente dopo la fine del dato.
1,:questo e' il dato,2/:questo e' un altro dato/3,,:questo è l'ennesimo
dato,,
Una testata può descrivere i contenuti delle righe che seguono, per esempio
i campi di un recordset:
1,:CLIENTE,2:CITTA,3,:STATO,
Le righe, per corrispondenza di tag, saranno:
1,:BIANCHI MARIO,2,:ROMA,3.:ITALIA,
1,:ROSSI FRANCO,2,:MILANO,3.:ITALIA,
oppure, simulando il risparmio su campi con contenuti non indicati (per
esempio a Bianchi manca lo stato, a Rossi la città):
1,:BIANCHI MARIO,2.:ROMA,
1,:ROSSI FRANCO,3.:ITALIA,
Se i contenuti delle "righe" non sono (o non si vuole che siano) ripetibili
(quindi descritti nella testata), la testata si limita a "fare presenza",
senza descrivere le righe che seguono che saranno a quel punto totalmente
autodescrittive, ovvero (sempre nell'esempio di campi e dati di recordset):
1,:CLIENTE,2,:BIANCHI MARIO,4,:CITTA,:ROMA,5,:STATO,6,:ITALIA,
1,:CLIENTE,2,:ROSSI FRANCO,4,:CITTA,:MILANO,5,:STATO,6,:ITALIA,
ovvero (per campi con contenuti non indicati, per esempio a Bianchi manca lo
stato, a Rossi la città):
1,:CLIENTE,2,:BIANCHI MARIO,3,:CITTA,4,:ROMA,
1,:CLIENTE,2,:ROSSI FRANCO,3,:STATO,4,:ITALIA,
Senza entrare nel merito delle prestazioni e, ovviamente, pensando a
programmi dedicati per la scrittura e la lettura,
Svantaggi (SE&O):
-Il carattere (o i caratteri) di fine dato deve essere riportato per ogni
dato indicato, anche se fosse quello di default.
-Si consumano dei caratteri per ogni tag (almeno 3, numero, : di fine tag e
crt di fine dato, almeno 4 se il crt di default non è applicabile) – In
realtà si potrebbe risparmiare il : di fine tag considerando la stessa
conclusa dopo il primo carattere diverso da secondo, ovviamente non
riportando informazioni "vuote" (perché allora il crt di fine dato sarebbe
identico e accodato al secondo carattere e riportando anche il carattere di
default).
-Si consuma una riga di testata (più o meno ampia) per ogni gruppo logico di
informazioni
-Per consentire una lettura ASCII (Line Input #) si deve supporre che le
informazioni non contengano caratteri "non stampabili" (Chr(0) Chr(26),
etc.), salvo dover leggere in binario.
Vantaggi (SE&O):
-Se i nomi delle informazioni (nell'esempio campi/dati di recordset) valgono
per tutto il set di righe che seguono la testata, pur dovendo essere
descritti tutti in testata (una sola riga), possono essere omessi nelle
righe o, meglio, reperiti nella testata tramite il numero, normalmente più
breve del loro nome.
-Le informazioni assenti (campi testo/memo vuoti="", campi numerici, boolean
o data pari a 0/False o, per tutti, Null, salvo, per questo, indicazione
esplicita perchè non è "" o 0...) possono essere integralmente omesse, con
guadagno di spazio
-Un unico file, grazie alle "testate", può descrivere più gruppi di
informazioni, anche non inerenti fra loro
-Il file contiene solo caratteri "stampabili" (salvo ovviamente caratteri
"non stampabili" nelle informazioni che però costringerebbero/imporrebbero
una lettura binaria)
PS: Non mi sfrucuglia l'idea proposta del raddoppiare il carattere usato
come tag se presente nei dati. Non mi torna come reperire l'inizio e la fine
dato... mi sfugge.

 in più.
Ok, sono un nano. A questa interpretazione non sarei mai arrivato :-(

 Cosa ne pensi ?
Che, per sprecare byte, tanto vale (come ora) che mi faccia spedire il
database :-P

 Ok, sono un nano. A questa interpretazione non sarei mai arrivato :-(
lupone, calma. siamo tutti nani...
e' un modo quasi proverbiale, non so se venga da madame de stael o qualcuno
del periodo, per indicare che il progresso e' -- eheheh -- progressivo, e ci
si basa su quello che hanno fatto prima di noi :)
non romantica ma medievale, come espressione, stando a eco:
http://fausto.eco.unibs.it/~segdss/eco/storica.html
oddio, questi dicono newton:
http://www.ba.infn.it/~zito/corso/tesi.html
ciao, nj.

 l'inizio e la fine dato... mi sfugge.
A me sfugge il perchè dell'indicare il crt di fine dato nel tag....
se usi i tag metti direttamente la lunghezza del dato che segue no? Così
puoi usare tutti i caratteri (anche quelli non stampabili), e ti eviti la
menata del raddoppio
ciaociao

 menata del raddoppio
quoto:
10:abcdefghij4:ecco1:1   ---> abcdefghij   ecco   1
Oppure usare un bell'array di stringhe  e usare GET e PUT direttamente da/su
file:
fa tutto VB in una sola istruzione.
Al limite usare un type e sempre GET/PUT
termoPilucco

 del periodo
La frase appartiene a Newton, poi ripresa da molti :-)

 
http://www.ba.infn.it/~zito/corso/tesi.html
Uh, allora sono un nano ignorante. E' vero.

 se usi i tag metti direttamente la lunghezza del dato che segue no?
No, era un'altra visione. Quella della lunghezza mi è strachiara, non volevo
consumare crt per indicare la lunghezza.

 Ok, sono un nano. A questa interpretazione non sarei mai arrivato :-(
non ho detto che sei un nano, ho detto che, anche se tu fossi un nano,
potresti riuscire a vedere più lontano dei giganti del passato.


[termoPilucco = 
circa_ter...@hotmail.com
 in
c60o9h$6i9cr$
1...@ID-188026.news.uni-berlin.de
] ha scritto:

E se i Type sono più d'uno (o nessuno?)
Devo descrivere completamente un database, la sua struttura integrale e i
suoi dati, di ogni tabella. E di lui non so niente. Ecco perchè ho pensato a
qualcosa di generico, applicabile a tutto, anche se l'esempio è quello di un
recordset.

 potresti riuscire a vedere più lontano dei giganti del passato.
L'ho capita e non mi sono sentito nanizzato. ;-)
Sono però molto ignorante perchè non ho mai sentito quella citazione.


ok, ma imho è comunque meglio, altrimenti ti precludi la possibilità di
poter trasferire dati contenenti caratteri non stampabili. Inoltre risparmi
l'interlinea, poichè la testata può stare adiacente all'ultima riga della
tabella precedente.
ciaociao

 Sono perň molto ignorante perchč non ho mai sentito quella citazione.
peccato.
tra tutte le "frasi storiche" con cui sono venuto in contatto, č quella che
mi piace di piů.
perň, all'ignoranza si puň sempre rimediare.


 Così puoi usare tutti i caratteri (anche quelli non stampabili
No, mi spiacerebbe, perchè (al di là del vedere/stampare il file, da pazzi!)
non andrebbe più la Line Input # con uno 0 o un 26 nel bel mezzo di una
riga... mi pare.
Però, a pensarci bene, nemmeno con un CR+NL nei dati (che verrebbe inteso
come fine riga, un bordello!) e, per esempio in un campo memo di testo,
possono esserci ... :-(
La logica (qualunque sia) resta valida, ma questo esclude (salvo noiose
trasformazioni in fase di costruzione del file) la pretesa di ottenere un
file di testo puro, insomma bisogna comporlo e leggerlo in modo binario, non
usando quindi Print # e Line input #

 di poter trasferire dati contenenti caratteri non stampabili.
None! E non capisco come un metodo li possa ammettere e un altro no visto
che il dato (raddoppi eventuali a parte) deve essere riportato come tale. Se
contiene 0 o 26 o vbCrLf?...
Se parliamo di un file di testo, certi caratteri non devono esserci (vedi
mio post recente), salvo, appunto, comporlo/leggerlo in binario. Non cambia
molto, ma quel file non è più visionabile/stampabile, insomma non è più
testo puro. E', certo, ASCII, ma non testo.


Forse io sono un po' gnucco (anzi sicuramente :)) ma prova a fare un
progetto, metti 2 bottoni e incolla:
Private Sub Command1_Click()
Open "c:\prova.txt" For Output As #1
Print #1, "ciao" & vbCrLf & Chr(0) & "lupo"
Close #1
End Sub
Private Sub Command2_Click()
Dim s_input As String
Open "c:\prova.txt" For Input As #1
s_input = Input(11, #1)
MsgBox s_input
Close #1
End Sub
se sai la lunghezza del dato che devi leggere non devi passarti il file in
binario.
Mi dici dove sbaglio?
ciaociao

 Mi dici dove sbaglio?
Non ho provato e mi fido, ma la Input è, di fatto, una lettura binaria (a
differenza della Line Input #).
Inoltre la Input non ha delle pippe con la virgola?, vabbè, non importa...
La cosa non mi spaventa perchè ho già le routines apposite, solo che non è
più un file di testo, insomma (fermo restando che sarebbe da pazzi farlo con
l'intento di interpretarlo) se lo visualizzi con NotePad, probabilmente non
te lo fa vedere nemmeno intero e se lo salvi (sventuratamente) perdi un tot
di roba.
Un file di testo puro, volendo (da pazzi) sarebbe invece editabile e
salvabile. Ci devo rinunciare...

 salvabile. Ci devo rinunciare...
Sinceramente mi era sfuggito il fatto che tu volessi editarlo a mano.....
;-)
ciaociao

 Print #1, "ciao" & vbCrLf & Chr(26) & "lupo"
Per leggere (tutto) ed evitare EOF devi aprire con For Binary.
Mi sono capito?


Sě, ti sei capito, e hai ragione :)
ciaociao

> Disse Fantozzi "... la corazzata Potionkin (?) è una ... pazzesca..."
"La Corazzata Potemkin è una cagata pazzesca!!!"
... 92 minuti di applausi ...
-- 
Rivolterò il mondo per trovarlo, e anche se andasse in Indocina uno dei 
nostri starà nascosto in una ciotola di riso pronto a sparargli nel culo.
(Pulp Fiction)

 l'affermazione dell'insicurezza...)
Ma va la' :)


 vada, siamo nani sulle spalle di giganti.
azz, non mi storpiare le frasi di Blaise Pascal, eh he he he !  :-)
ciauz !
Soviet
P.S.
Era : <<se ho visto cosě lontano, č perché sono montato sulle spalle di
giganti>>


 azz, non mi storpiare le frasi di Blaise Pascal, eh he he he !  :-)
'azz: madame de stael, newton e/o questa/o qui sopra...
E io non solo non ho mai sentito la frase, ma solo del secondo ho una
pallida idea di chi fosse...
Bah, troppo vecchio per mettermi a studiare. Nella prossima vita vi frego
tutti, neh?!


CUT


> termoPilucco.tardivo :-P (e intanto Marg gongola)
Ottomano ancora più tardivo.... ESPIDAMA?
Che significato ha? :-8
bye
-- 
Esistono 10 tipi di persone: chi conosce il binario e chi no.
Gestione Ottica - Gestionale per Ottici e Programmi Gratuiti su:
http://www.nicolaottomano.it

 Che significato ha? :-8
I al posto di 1 (o IT), P dopo O.
Si chiama ESP<ZERO>DAMA e su 'sta cosa ci si sta giocando da un po'. ;-)

 Perchè?
Generi una combinazione e controlli se è presente nel database.
Se non è presente la usi come divisore dei dati. Se è presente ne generi
un'altra.
La combinazione che usi la salvi nell'header del file. Il programma andrà a
leggere l'header e capirà quale è la combinazione che divide i dati.
Così hai il 100% (leggasi CERTEZZA MATEMATICA) che i dati non potranno
confondersi con i divisori dei dati.


 ;-)
Ok ora ho capito...
Però mi domando quale criterio usi per dare i nomi ai tuoi programmi. :-)


 O ancora non ho capito bene lo scopo della missione ?
La missione è chiara, ma (grazie alle discussioni) non c'è verso di fare un
file di testo puro (un campo, testo memo, semplicemente, potrebbe contenere
un vbCrLf), quindi, salvo complicazione XML style (la Potemkin, IMHO)
occorre andare (sia in scrittura che lettura) in binario. Non è un problema,
mi spiace solo un po'...

 confondersi con i divisori dei dati.
Per quello mi basta una carattere per ogni informazione, da decidersi in
funzione dell'informazione stessa.

 essere servito come ti aspetteresti
Sě, ma la parte finale mi sa tanto di club de masoch... ;-)
In altre parole, penso che una Line Input # altro non sia che una lettura
binaria sequenziale, con, in piů, qualche controllo su vbCrLf che serve da
fine riga.

 in funzione dell'informazione stessa.
Quindi, in sostanza, che cosa hai deciso?
Non mi va di leggere tutto il flame (parlare di thread mi sembra riduttivo).
;-)


 :-)
Cerca su Google in questo NG. Ormai di me si sa tutto... :-P

 riduttivo). ;-)
A me non sembra un flame, comunque...
Non potendo usare testo puro, vado in binario (pur con molto testo, per
forza di cose), devo solo decidere (a questo punto non maggiore libertà)
come strutturare le informazioni per garantire la massima fruibilità (quindi
anche la sequenza e l'ordine sono importanti).
Non è così immediato, più d'uno ha infatti pensato a un recordset. No: devo
descrivere un intero database, quindi sue proprietà, comprese tabelle,
campi, indici e relative proprietà, nonchè, ovviamente, i contenuti. Il
tutto in un unico file. Non è così semplice perchè le strutture sono
diverse. Diverse.
Inoltre, da che ci sono, vorrei fare qualcosa che vada bene, pur con la
scelta decisionale di chi ci lavora, per qualsiasi cosa, non solo per i
database...

 per i database...
Azz... in questo caso ti auguro buona fortuna ( e buona notte, visto che ora
vado a dormire).


[Lupo = 
circa_LupoOrm...@libero.it
 in
c61gh3$6sagu$
1...@ID-174464.news.uni-berlin.de
] ha scritto:

Ecco:
http://makeashorterlink.com/?C2CF65118

 che ora vado a dormire).
Ecco un altro che non ha mai visto ESP0DAMA che, praticamente (da adattare),
fa già tutto ciò.
Lo ritirerò quel progetto. :-P 'notte.

 database...
Praticamente la "lingua madre", o radice comune, di cui se ne cerca una 
traccia da secoli :)
-- 
Rivolterò il mondo per trovarlo, e anche se andasse in Indocina uno dei 
nostri starà nascosto in una ciotola di riso pronto a sparargli nel culo.
(Pulp Fiction)

 ciauz !
mettiti d'accordo con drizzt :)

 tutti, neh?!
non c'e' bisogno di studiare. quando hai qualche minuto, scuriosa sulla
rete. molto c'e'. e/o poi passa in biblioteca e/o libreria. a volte anche
leggere su carta non e' male.
ciao, a.
specie quando torni da un giorno via e un disco con 4 gb di ebooks e'
frullato, mentre i libri su carta ci sono ancora tutti.

 frullato, mentre i libri su carta ci sono ancora tutti.
Urca :-( Ma la rete c'č sempre, a meno che non siano ... d'autore.
Per il disco, poi, aiuta non prenderne mai piů della stessa marca.
Non la sicurezza, nč la garanzia, ma il reclamo della coscienza...

 Per il disco, poi, aiuta non prenderne mai più della stessa marca.
effettivamente ha smesso di produrne e passato tutto credo a hitachi. sara'
un caso ?

 
http://makeashorterlink.com/?C2CF65118
Questa la metto nei Preferiti IE :-)
bye
-- 
Esistono 10 tipi di persone: chi conosce il binario e chi no.
Gestione Ottica - Gestionale per Ottici e Programmi Gratuiti su:
http://www.nicolaottomano.it

 Lo ritirerò quel progetto. :-P 'notte.
Nooo! E' così bello... e poi mi è utile per convertire i db da Access97 a
2000.


 nell'eccessiva precisione del calcolo>>
trad. it.: i pc di matematica non capiscono una sega, salvo i primi pentium
:)


 per i database...
come stai procedendo ? alla fine mi interessa la struttura che hai adottato,
io spero e punto su una cosa simile :
[LunghezzaCampo][nomecampo..][Lunghezzastringa][valorestringa...]
credo sia la cosa + generica possibile, altrimenti inventati uno standard
tuo per le teste , le proprieta' e i campi data e via a codificare ^_^
-- 
<Gigio2K>
--- 
http://www.g2kweb.it/gigio2k
 ---
Nokia -> I.T.H.N. -> 
http://www.ithn.it/
VB -> I.C.L.VB -> 
http://www.it-lang-vb.net/

 [LunghezzaCampo][nomecampo..][Lunghezzastringa][valorestringa...]
Sì, sarà qualcosa di simile, ma da leggersi in binario, anche se conterrà
molto testo.