Newsgroup: it.comp.lang.visual-basic
Titolo: [?] Salvare oggetti

Supponiamo di avere due classi:
clsOggetto, clsDatabase
dove clsOggetto rappresenta un oggetto qualsiasi e clsDatabase non tanto
db in senso stretto, ma piu' genericamente un contenitore in cui si
possono salvare oggetti.
Secondo voi e' meglio implementare una funzione del genere
clsDatabase.SalvaOggetto(mioOggetto as clsOggetto)
o una cosi'?
clsOggetto.Salva(mioDB as clsDatabase)
-- 
Samuele Battarra
prova il mio newsreader:
http://space.virgilio.it/batt...@tin.it/programmi/news/

 clsOggetto.Salva(mioDB as clsDatabase)
io direi la prima, ma la questione è interessante.
Salutoni
Sergio

 clsOggetto.Salva(mioDB as clsDatabase)
Fra le due senz'altro la prima. A meno di casi molto
particolari il singolo oggetto non dovrebbe avere neanche
"coscienza" dell'esistenza di un DB di oggetti del suo tipo.
In ogni caso mi sembrano entrambe un po' "strane".
Sarebbe piu' consona, IMO:
   clsDatabase.SalvaOggetto(IndexKey As Variant)
a cui si passa l'indice o la chiave con cui l'oggetto e'
memorizzato nel DB.
Inoltre suggerirei l'aggiunta del metodo:
   clsDatabase.Salva()
che salva tutti gli oggetti presenti nel DB evitando di
costringere il chiamante a salvare il DB oggetto per
oggetto.
Variante:
   clsDatabase.Salva(ByVal NomeFile As String)
in cui specificare il nome del file ;)
Just my two eurocent,
Lokar
-- 
Sito Comune: 
http://www.it-lang-vb.net/
Manifesto: 
http://www.it-lang-vb.net/docs/Manifesto.txt
Statuto: 
http://www.it-lang-vb.net/docs/Statuto.txt
UGIdotNET - 
http://www.ugidotnet.org

 possono salvare oggetti.
Per salvare su disco un'istanza di un oggetto devi renderlo persistente.
Mai provato a fare qualcosa del genere, ma posso darti qualche spunto per
due prove.
Le classi hanno una proprietà che permette di renderela persistente, guarda
la finestra delle proprietà.
Moreno aveva scritto un articolo sull'argomento.
Dovresti ancora trovarlo sul Sito Comune
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

 
Forse ho capito cosa intendi, e penso che tu abbia frainteso :)
Allora clsDatabase rappresenta un contenitore.
Con l'operazione di salvataggio non intendo quella di salvare
su database (o anche su file) gli oggetti contenuti in clsDatabase,
ma quella di mettere l'oggetto in questione dentro clsDatabase che,
lo ribadisco, non e' per forza un database, puo' essere anche un file
o un semplice buffer in memoria.
Quindi il tuo clsDatabase.SalvaOggetto(IndexKey As Variant) non č valido
perche' non gli vengono passati i dati da salvare, mentre
clsDatabase.Salva() č inutile, gli ogetti che sono gia' dentro il db
per definizione sono gia' salvati.


 clsOggetto.Salva(mioDB as clsDatabase)
Sicuramente la prima, perché non ha senso che la classe clsOggetto debba
conoscere i dettagli della classe clsDatabase, cosa che è necessaria se
si vuole implementare la seconda. 
Ha senso un metodo clsOggetto.Save(), dove l'oggetto sa come rendersi
persistente, ma creare un accoppiamento con un altra classe è
decisamente errato.
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.

 clsOggetto.Salva(mioDB as clsDatabase)
Forse diro una ca**** ....
Ma le collections non sono contenitori di classi?
Mi pare abbiano 4 metodi e uno e ADD
--
Morfeus®
Free Joint
 :PII

clsOggetto.Salva(mioDB as clsDatabase)
Come hanno detto altri, decisamante la prima.
Colpa del parametro di clsOggetto.Salva.
Se infatti clsDatabase è un contenitore di oggetti (mi sembra di intuire
anche di oggetti clsOggetto), allora la seconda soluzione potrebbe
creare un riferimento circolare. La seconda mi piace senza il parametro,
ovvero permettere all'oggetto di consolidare se stesso; se però, per
consolidarlo, serve un riferimento alla classe che lo contiene, allora
nun se pote.
Ciao,
Moreno
-- 
sirri at morenosoft dot com
Moreno Sirri VB Site - 
http://www.msvbsite.net
---------------------------------------------------------------------------
Le risposte alle tue domande le trovi sul Sito Comune di questo NewsGroup:
 
http://www.it-lang-vb.net
---------------------------------------------------------------------------

 o un semplice buffer in memoria.
Ah, ecco :)
Il metodo "caratteristico" per aggiungere un oggetto a una
"lista" di oggetti e'
   clsDatabase.Add(ByRef ogg As clsOggetto)
Puoi utilizzare la creazione guidata classi di VB e creare
un "insieme" di oggetti (dopo che hai definito la classe
oggetto ovviamente). La creazione guidata provvedera' ad
aggiungere tutti i metodi necessari alla gestione di
aggiunta (Add), rimozione (Remove), accesso (Item), e ciclo
(_NewEnum per il For Each ...).
hth,


 
Ci daro' un'occhiata.


 
Mi piace l'idea di rappresentare il db come insieme, anche se
pero' per fare un lavoro fatto bene bisognerebbe fargli digerire
oggetti di tipo eterogeneo.


 si vuole implementare la seconda. 
Pero' con la prima la classe clsDatabase deve conoscere tutti i dettagli
della classe clsOggetto e non è detto che questo sia possibile.


 
Anche a me piacerebbe di piu'.
Potrei evitare di passare clsDatabase poiche' alla fine di questa
classe nel programma ne esistera' un unica istanza globale, ma non mi
sembra una soluzione molto pulita.


 
Si, sono contenitori di classi, ma solo in memoria.


 Si, sono contenitori di classi, ma solo in memoria.
Ma Imho è adattabilissima al tuo problema ,la precarichi all'avvio
e PUO contenere oggetti eterogenei.Anche se qualche altro
trucchettino scondo me in giro c'è ,che sò una DLL già avviata?
Mi sfugge l'utilizzo pratico che ne vuoi fare ma è il pricipio su cui
si basa anche vb.
Mi pare di capire che anche Lokar ti suggeriva una cosa del genere...
 Ciao
Alessandro


 si basa anche vb.
In pratica sto progettando la struttura della nuova versione del mio
programma per le news (vedi firma), in pratica sto progettando il
sistema per salvare i messaggi nel db, però volevo lasciarmi la porta
aperta per poter implementare facilmente una eventuale versione in cui
il salvataggio dei messaggi avvenisse su file anzichè nel db.



Collection
--ClsMessaggioFl
--ClsMessaggioDb
Modulo
--Sub MetodoAdd(Obj as Object)
---if Typeof Obj Is clsMessaggiodb then
    call clsMessaggioDb.Writedb()
    Collection.Add Key...........
   Elseif typeof Obj Is clsMessaggioFl then
    ...
   End If
--end sub
ClsMessaggioFl
--Sub WriteFile()
--End Sub
ClsMessaggioDb
--Sub WriteDb()
--End sub
Gli Oggetti poi li recuperi ciclando e con gli Item(Key) messi a
disposizione
dalla Collection,li cancelli con Remove preoccupandoti di serializzarli ad
hoc
Pensa che gestione ne viene fuori...
A logica dovrebbe funzionare...in pratica il problema e la
"dimensione"(Count) della Collection che ne viene fuori
e la gestione di caricamento qui ancora non implementata...il tutto a
Run-Time...Certo che legare un Nick ad una proprietà
della Classe aiuterebbe ma la fantasia di creazione di una cosa di questo
tipo è veramente
da studiarla a tavolino.Sicuro che questa è la strada migliore....Ho i miei
dubbi
Se ci pensi creare in una collection la struttura di un Db non è poi così
artificiosa quanto potrebbe sembrare,dato che lo è di suo.
Peccato che in Vb6 l'ereditarietà non è contemplabile avresti vita facile...
prova a spostare tutto in Dll scritte in C o meglio ancora se ti butti sul
Framework di casa Redmond....??? se lo puoi fare naturalmente...
Non sò quanto la mia analisi possa essere giusta ma è la prima cosa che
mi è venuta iin mente,però è intrigante come cosa ;)
Buona Fortuna
