Newsgroup: it.comp.lang.visual-basic
Titolo: [.Net] Interface

Spero che qualcuno mi possa delucidare, perchè a discapito del
forse buon libro di Balena, io sto diventanto imbecille.
Ora il dubio sto giro è sulle Interface. Pagine 232 ... o giù di li
del suo libro ... da premettere che non spiega bene cosa sono
e questa è una pecca per chi magari si avvicina come primo
linguaggio al .net ... ma questo sarebbe il problema minore nel
mio caso.
Quello che non riesco a capire è che sembra che molti fattori
automatizzati del vecchio vb6 siano andati persi.
In particolare ieri sera mi sono letto e riletto un 3 o 4 volte il
codice che implementa l'interfaccia IEnumerable IEnumerates
se non dico boiate.
Bene, sembra come che se io voglia usare una classe dentro
ad un for each next devo implementare sta interfaccia ... mi sta
anche bene ... ma il perchè in alcuni punti Balena faccia
Class X
    Implement IEnumerable
    Public s as string
    Class Y
        dim s as string
        Sub New (byval s as string)
            me.s = s
        end sub
        Function GetCurrent .... Implements IEnumerates.qualchecosa
   (Scritta a memoria da ieri sera) ... non mi torna perchè getcurrent
debba fare l'implements di quell IEnumerate qualchecosa ...
E non viene spiegato ... o forse ero troppo rincoglionito una decina
di pagine prima da aver omesso la lettura.
Poi, se qualche anima pia, mi spiega a che diavolo servono anche
le altre interfaccie, perchè pure li non traspare ... esempi pratici del
tipo
con sta IEnumerate (sempre se non ho capito male) do la possibilità
alla mia classe di essere enumerata all'interno di un ciclo for each
Ma le altre ...
Corrado, confido anche in te ...
-- 
Saluti
Andrea Moro

 alla mia classe di essere enumerata all'interno di un ciclo for each
Un'interfaccia viene comparata dai più come un contratto tra le classi.
Forse proprio in questo NG se ne è parlato poco tempo fa.
In pratica dice che la tua classe *deve* implementare i membri dichiarati
nell'interfaccia.
E' una sorta di sicurezza.
Ti faccio un esempio che forse è più semplice del solito insulso e
incomprensibile dell'interfaccia Persona.
La classe Array implementa il metodo Sort() che serve ad ordinare gli
oggetti al suo interno.
Ora, finchè si tratta di un array di stringhe sarebbe facile ordinarle.
Ma metti che tu hai il tuo array di Clienti, i quali sono una classe con
Nome e Cognome come proprietà e non solo un valore.
Come farebbe la classe Array a ordinare i tuoi clienti come vuoi tu?
Tu potresti volerli ordinati solo per Nome, solo per Cognome, per Cognome +
Nome o per Nome + Cognome.
Ma perchè dico ciò? :)
Perchè il metodo Array.Sort() *richiede* un array di oggetti che
implementano l'interfaccia IComparable, che definisce semplicemente il
metodo CompareTo().
In questo modo, Array.Sort() è sicuro ti poter utilizzare il metodo
CompareTo della tua classe, dato che *sicuramente* è implementato, dato che
implementi IComparable.
E in questo metodo tu ci metti il *tuo* metodo di ordinamento, es:
Class Cliente Implements IComparable
    Public Nome As String
    Public Cognome As String
    Public Function CompareTo(Object AltroCliente) As Integer
        ' L'ordinamento dei clienti avviene per Cognome + Nome
        Dim AC As Cliente = DirectCast(AltroCliente, Cliente)
        Return (Nome + Cognome).CompareTo(AC.Nome + Ac.Cognome)
    End Function
End Class
Alcuni dicono di non poter fare a meno delle interfaccie, personalemte (e
probabilmente da ignorante :P ) le trovo piuttosto inutili, a parte casi
particolari come questo, anche perchè spesso si può arrivare allo stesso
risultato facendo l'override di metodi di classi base.
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

In sostanza è una firma, laddove il notaio di turno è l'interfaccia scritta
a priori dalla MS. Quindi da garanzia a terzi che usano la tua classe
di poter scrivere ad occhi chiusi tuaclass.sort perchè il .sort deve
e non può non esserci.
La zuppa ... è tutta qua ... quasi chiaro ... credo che la chiarezza
completa potrò averla solo quando inizierò a smanazzarci sopra.
Però concordo con te con la "ipotetica" inutilità ... sempre da profano
e da attuale non smanettante.
-- 
Saluti
Andrea Moro

 ha scritto nel messaggio
news:bjf4bs$i2u37$1...@ID-61006.news.uni-berlin.de...

[SNIP]
L'utilita' veramente dovrebbe essere evidente proprio dall'esempio di Zanna:
Il codice che fa funzionare il .Sort e' stato scritto una sola volta, ed
utilizza internamente soltanto oggetti di tipo IComparable... se volessi
fare una cosa del genere senza interfacce avresti dovuto utilizzare
variabili Object, con l'ovvio problema che *a runtime* il codice avrebbe
dovuto verificare ogni volta se l'oggetto in questione supporta il metodo
CompareTo, cone i parametri corretti, senza offrirti nessun genere di
controllo a monte.
Viceversa in questo modo sei garantito sulla robustezza del tuo codice,
proprio in virtu' del "contratto" di cui si diceva.
Il fatto di poter effettuare l'override della classe base in questi casi non
aiuta, perche' saresti comunque costretto a scrivere codice specifico per la
classe Persona e tutte quelle derivate, la classe Animale e tutte quelle
derivate ecc... le interfacce ti permettono di accumunare in alcuni
comportamenti (= i membri delle interfacce stesse) classi completamente
slegate tra di loro.
In .NET e' molto difficile che tu possa fare a meno di utilizzarle, perche'
governano buona parte dei meccanismi del framework stesso
Ciao
--
Luca Dormio - 
luca....@tin.it
________________________________
"Marty, non stai ragionando in maniera quadridimensionale"
Dr. Emmett L. Brown

 Il fatto di poter effettuare l'override della classe base in questi
No l'override non l'ho chiamato per niente in causa ... non io almeno.
Anche li ci sono alcune cose oscure che adesso non ricordo.
Più che sull'override, mi pare fosse sul discorso degli shared e compagni.
--
Saluti
Andrea Moro

 e da attuale non smanettante.
Attenzione a dire certe cose, Corrado ad es. sembra non riuscirne a fare a
meno e non so se mi sono spiegato :)


Ci devo smanazzare perchè continuo ad avere le idee leggermente
confuse ... in pratica il tuo esempio è lo stesso di Balena ... che
ugualmente mi trae in inganno ...
Siamo d'accordo. Interffaccia = sicurezza che requisiti base vengano
rispettati, dove per requisiti intendo (funzioni e variabili e simili) che
vanno gestite nella classe che deriva dall'interfaccia ... questo in
buona sostanza è quanto succede anche con il vb6.
Ma il perchè poi nell'esempio di Balena ci siamo function x implements
ecc. ecc. ... questo non l'ho capito ...
Cioè gli vado a dire che quella funzione deve rispettare i requisiti
di quel dato metodo di quella data interfaccia?
E allora perchè fare la dichiarazione ad iniizo classe implements
qualchecosa? Non è una ripetizione?
-- 
Saluti
Andrea Moro

 Più che sull'override, mi pare fosse sul discorso degli shared e compagni.
Gli shared li puoi vedere semplicemente paragonandoli alle vecchie classi VB
GlobalMultiuse: puoi usare le funzioni Shared di una classe senza avere
l'istanza della classe.
Un esempio?
Array.Sort() :)
Array è il tipo, non un'istanza di classe, Sort è un metodo Shared (static n
C#).


 ecc. ecc. ... questo non l'ho capito ...
Semplicemente perche' devi specificare che (nel tuo esempio) la funzione
GetEnumerator non e' una funzione qualunque della classe ma e' la funzione
che implementa la corrispondente GetEnumerator dell'interfaccia IEnumerable.
In questo modo il compilatore e' in grado, tra l'altro, di obbligarti a
definire X con la stessa signature (parametri, tipi di ritorno ecc...) di
quella che stai implementando; questa funzione sara' poi quella invocata
quando passerai un istanza della tua classe ad un metodo generico che
accetta oggetti IEnumerable.
In VB6 avresti trovato la stessa cosa con la sintassi
'TuaClasse
Implements IEnumerable
Public Function IEnumerable_GetEnumerator
'metodo che implementa quello dell'interfaccia
End Function


 ogni tipo che intendevi utilizzare.
[SNIP]
Volendo puoi fare la stessa cosa anche in VB6, solo non e' utilizzabile con
i tipi base, che li' non sono oggetti.


Uhm Uhm ... ci sono quasi ... ancora una sforzo ... e per ora di
cena digerisco ;)
Stesso vale per la risposta di Zanna ... devo solo avere il tempo
di provare, ma sto finendo alcune modifiche ad un progetto vb6
e poi finalmente mi potrò dedicare a .net, salvo casini ulteriori
e /o altre gatte da pelare in generale.
Chissà a quando il lieto evento ;).
Ciao
Andrea

 qualchecosa? Non č una ripetizione?
Nel sito
http://www.it-lang-vb.net/
 sono pubblicati due proggetti:
1- ConfrontoArray.
L'interfaccia č costruita dal programmatore
(i dati sono presenti in un file.mdb)
Per connettersi al DB č utilizzata un'Interfaccia composta da:
 - due metodi
 - una definizione di evento
(Per il collegamento č possibile una metodologia piů semplice)
Se nella classe provi a commentare es. Event, l'Implements avverte che Event
deve essere implementato.
Quindi, presumo, che i metodi,le Property, gli eventi,le Sub, le Function,
ecc. , presenti in:
Public Interface IyourInterface
sub ..
Event
...
End Interface
devono essere tutti implementati nella classe che implementata
l'interfaccia.
Possiamo dire che l'interfaccia definisce un comportamento ?
Se all'interno hai tre menbri, la classe li devi implementare tutte e tre.
2- ClassArraySort. Utilizzo di interfaccie presenti nella libreria delle
classi del Framework
Quindi i metodi son quelli forniti a corredo
(i dati sono presenti in due file.xml)
si utilizzano due interfaccie
1.1- IComparable
1.2- IComparer
Per il punto 1.2 vorrei sapere come ordinare le coppie di colonne senza
l'utilizzo dell'interfaccie fornite dal Framework
(ammetto che non ho tentato altre vie, in considerazione delle poche righe
di codice utilizzato nell'esempio)
giuseppeD

 risultato facendo l'override di metodi di classi base.
Sinceramente è la stessa identica cosa. Tu utilizzi a tutti gli effetti 
un'interfaccia senza "esplicitare" la cosa utilizzando l'apposita
keyword. Per esempio in C++ *non* esiste una qualche keyword Interface,
ma non per questo sei impossibilitato ad utilizzare le interfacce.
Anzi, hai una flesibilità ancora maggiore...
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.

 Sinceramente è la stessa identica cosa.
[SNIP]
Non proprio "identica"... non essendoci ereditarieta' multipla in .NET,
l'uso delle interfacce ti permette di riutilizzare in maniera sicura lo
stesso codice anche con oggetti che *non* derivano dalla stessa classe base


 stesso codice anche con oggetti che *non* derivano dalla stessa classe base
Sě, giustissimo, io la vedevo dal solo punto di vista di utilizzo delle
intrfacce, non da un punto di vista piů generale.
