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

Ciao a tutti
Sto studiando un pò l'utilizzo di Implements perchè mi risolverebbe un bel
problemino
e volevo una conferma se il metodo che ho utilizzato è il migliore.
Il mio problema è :
Definire una classe standard cosi :
    ClasseA
      Metodo1
       'Codice
      Fine Metodo1
      Proprietà1
       'Codice
      Fine Proprietà1
    Fine Classe
Definire una classe Specializzata ClasseB che contenga il metodo e la
proprietà
di ClasseA e una proprietà Proprieta2 (ClasseB Compatibile con ClasseA).
Se faccio cosi :
    ClasseB
     Implements ClasseA
      Private ClasseA_Metodo1
      'Codice
      Fine ClasseA_Metodo1
 
      Private ClasseA_Proprietà1
      'Codice
      Fine ClasseA_Proprietà1
      Proprietà2
      'Codice
      Fine Proprietà2
    Fine Classe
 
ClasseB può essere assegnata ad una variabile di tipo ClasseA
ma una variabile di tipo ClasseB non ha disponibili Metodo1 e Proprietà1
a meno che non la assegni ad una variabile di tipo ClasseA,
cosa che a me da seri problemi.
La soluzione che ho utilizzato è la seguente :
    Classe B
     Implements ClasseA
      Private ClasseA_Metodo1
      'Funzione1
      Fine ClasseA_Metodo1
 
      Private ClasseA_Proprietà1
      'Funzione2
      Fine ClasseA_Proprietà1
      Metodo1
      'Funzione1
      Fine metodo1
      Proprietà1
      'Funzione2
      Fine Proprietà1
      Proprietà2
      'Codice
      Fine Proprietà2
    Fine Classe
Che per quanto funzioni e risolve le mie esigenze la trovo un po ridondante
Mi sapreste dire se esiste una strada migiore?
Crazie a tutti
Ciao
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Ciao
ciaociao

 cosa che a me da seri problemi.
VB6 ha delle grosse limitazioni nell'uso di implements.
Il metodo che hai usato č corretto, ma non capisco i problemi che hai con
l'uso di ClasseA.
Riassumo:
In VB6, tu devi fare:
Uso un nome "da specifiche" cosģ si capisce anche meglio chi č
l'interfaccia.
IClasse (interfaccia senza implementazione)
    Sub Metodo1
ClasseA (classe che implementa IClasse con codice)
    Implements IClasse
    Sub Metodo2
Ora tu puoi fare
Dim IC As IClasse
Dim C As ClasseA
Un linguaggio appena serio darebbe a C sia Metodo1 che Metodo2, VB6 solo
Metodo2 :(
Perņ tu puoi usare indifferentemente le due dichiarazioni, dato che si
riferiscono alla stessa istanza:
Set C = New ClasseA
Set IC = C
C.Metodo2
IC.Metodo1
Perņ non ho ben chiaro a cosa ti serva.
Questa cosa ha senso solo se tu avessi ad es.
Classe2
    Implements IClasse
    Sub Metodo3
Public Sub FaiQualcosa(C As IClass)
    C.Metodo1
End Sub
Dim C1 as ClassA
Dim C2 As ClassB
...
' Posso chiamare tranquillamente FaiQaulcosa
' indifferentemente su C1 che su C2
Call FaiQualcosa(C1)
Call FaiQualcosa(C2)
Ciao
--
Math Parser : 
http://www.neodatatype.net
FlowChart   : 
http://www.neodatatype.net/dump/flowchart/dir.asp
Sito Comune : 
http://www.it-lang-vb.net

la mia esigenza parte da quando, scontento della flexgrid gerarchica di
microsoft
ho deciso di farmene una.
Successivamente ho deciso di implementare anche l'editazione diretta sulle
celle da tastiera
pensando che una cella poteva contenere o un valore (es un importo)
o una foreinkey da decodificare e che sulla cella comparisse il numero
anzichè
la decodifica mi faceva un po schifo quidi ho fatto cosi:
alla type che rappresentava una cella :
Public Type RecCella
 Alignment As VBRUN.AlignmentConstants
 FormatString As String
 FontName As String
 Fontsize As Single
 Testo As String
 Width As Long
 BKColor As OLE_COLOR
End Type
per l'editazione ho aggiunto :
EditorObject As gpField
gpField è una classe dove a parte alcune proprietà di scarso interesse
ci sono :
Style as gpfStyle
DropDown as gpDropDown
TextBox as gpTextBox
'--------------------------------
enum gpfStyle
 gpfDropDown
 gpfTextBox
end enum
DropDown classe che rappresenta un array precaricato di ID e descrizioni
TextBox classe che rappresenta un textbox sul quale editare il valore
'---------------------------------
Quando la griglia è in editazione (Tramite Property)
se una cella prende il fuoco e EditorObject non è nothing:
Se style è gpfTextBox:
compare una textbox dove viene digitato il valore
Se style è gpfDropDown:
compare una combobox con l'array precaricato dove scelgo la descizione
mentre nella cella è contenuto il valore della chiave
cosi l'operatore sceglie la descizione, quando scivo in tabbella scrivo la
chiave:
Questo andava bene se per esempio dovevo scegliere un insieme di comuni(es
quello di residenza)
tutti codificati e relativamente limitati
Il porblema era quando la foreikey rappresentava una chiave ad un record più
complesso
esempio l'ID di un cliente che posso ricercare per cognome, nome ,codice
fiscale e via divendo
e qui una comboBox non mi andava più bene
Soluzione adottatta :
all'enum gpfStyle ho aggiunto gpSelector e a gpfiled ho aggiunto selector as
gpSelector
gpSelector è un'interfaccia che ha esclusivamente i metodi
GetKey
getDescription(sKey)
Per qualunque tipo di ricerca complessa devo fare la chiave resituita sarà
sempre un numero
a questo punto se devo ricercare un fornitore faccio una gpFornitoreSelector
che implementa gpSelector dove in getKEY di gpfornitore selector metto il
codice per
la form di ricerca complessa a piacere e che mi restituisce il suo
Identificativo
getDescription mi serve per reperire la stringa rappresentativa dell'ID del
fornitore
che voglio visualizzare nella cella Es cognome e nome
gpfornitoreSelector la assegno a gpSelector della cella che mi interessa e
il gioco è fatto
il vantaggio è che per la decodifica es dell'ID un fabbricato (il problema
reale che mi ha fatto fare tutto ciò)
basta che implemento la GPFabbricatoSelector e la assegno all'oggetto della
cella senza
intaccare la generalità della definizione della sua struttura
oggi ho provato ed è andato tutto bene funziona alla grande
spero di essere stato abbastanza chiaro
ciao


 Crazie a tutti
PreCo :)
Ciao,
Moreno
Inviato da 
www.mynewsgate.net

 astratta
Non ci avevo mai pensato... in questo modo simuli anche l'ereditarietą :)



Perche ad un certo punto ad una variabile di tipo classeA generica devo
poter assegnare variabili di tipo ClasseB, ClasseC, ClasseD... tutte che
implementano Classe A e poterci lavorare con i metodi e le prioprietà di
classeA


 classeA
E per fortuna che non funziona così, altrimenti l'OOP va a farsi benedire :)
Questo se ho inteso bene quello che vuoi, cioè
Dim A As ClasseA
Dim B As ClasseB
...
Set A = B
A.Metodo1 ' Usare in codice di ClasseA e non di ClasseB
          ' *** Questo NON lo puoi fare, verrà chiamato il
          ' *** metodo di ClasseB (giustamente!)
Se invece intendi usare i metodi definiti (e non implementati) di ClasseA il
sistema qui sopra funziona perfettamente.


Scusate ma forse non mi sono spiegato bene.
io voglio definire una interfaccia generica (che ho definito ClasseA per
semplicità e forse sta qui l'equivoco perche avrei dovuto dire
IntrfacciaA)che dovrà essere comune a più modulti di classe : ClasseB,
ClasseC, ClasseD classi che fanno cose diverse ma che hanno in comune di
restituire un ID di una entità diversa per classeB, ClasseC, ClasseD e
ognuva di queste tre classi avrà la sua form di ricerca che cerca su tabelle
diverse ma che cmq restituiranno sempre il fatidico ID (di tabelle diverse)
La visualizzazione della form si ha con il metodo Ricerca()as long . Se devo
decodificare l'ID ha il metodo Decodifica(ID) as string.
Ricerca e Decodifica sono Comuni a tutte le classi ma ogni classe che
implementa l'interfaccia comune fa cose diverse
a questo punto in una griglia fatta da me nella type cella c'e una
interfaccia di Tipo InterfacciaA che qualunque classe gli assegni (ClasseB,
ClasseC, ClasseD) è in grado di sapere assegnato l'id nella proprietà testo
della cella quale Testo visualizzare all'operatore tramite il metodo
Decodifica di qualunque classe ci sia B,C,D
cmq l'ho già implementato e funziona. l'unica scomodità è che mi aspettavo
come in altri linguagi che il semplice fatto che dicessi Implemnts
InterfacciaA mi fornisse per le nuove classi l'intefraccia comune senza che
dovessi definire i metodi per intefaccia1 con private Interfaccia1_Metodi e
per classeB
 con public ClasseB_Metodi visto che per esempio in delphi lo facevo molto
tranquillamente

--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 tranquillamente
Io continuo a non capire, ma non importa se hai risolto :)
Un'interfaccia non ha implementazione, in nessun linguaggio.
L'ereditarietà è un'altra cosa, ma come dicevo puoi aggirare la cosa
assegnando a una variabile di tipo interfaccia l'oggetto di tipo
"implementato", così puoi chiamare i metodi ridefiniti (che, essendo metodo
di interfaccia vanno per forza implementati, ma li avresti dovuti
implementare comunque dato che ognuno implementa algoritmi diversi).
