Newsgroup: it.comp.lang.visual-basic
Titolo: [?] [.NET] Ereditarità

Poniamo di avere il seguente codice
--------------------------
 Class Citta
      Inherits Object
 End Class
 Class Paperopoli
      Inherits Citta
 End Class
 Class Topolinia
      Inherits Citta
 End Class
 Class Personaggio
     Public  Sub VaiA(ByVal destinazione As Citta)
     End Sub
 End Class
 Class Paperino
      Inherits Personaggio
      Public  Sub VaiA(ByVal destinazione As Paperopoli)
      End Sub
 End Class
--------------
Adesso, in qusto modo io posso fare
    Dim pap As Paperopoli =  New Paperopoli()
    Dim p As Paperino =  New Paperino()
Però così p ha due VaiA(),
    VaiA(Citta)
    VaiA(Paperopoli)
E' possibile sfruttare l'ereditarietà, quindi il codice scritto in
Personaggio.VaiA() (e magari il fatto che Paperino eredita direttamente
il metodo senza ridichiararlo), nascondendo però Personaggio.VaiA()
in favore di Paperino.VaiA()?
Spero di essermi spiegato :)
Ciao
--
Math Parser : 
http://www.neodatatype.net
Sito Comune : 
http://www.it-lang-vb.net

 Spero di essermi spiegato :)
credo che sia il significato della parola chiave shadows
hth
--
Salutoni
Sergio

 in favore di Paperino.VaiA()?
Se le classi sono *esattamente* come quelle che hai scritto, p ha solo
VaiA(Paperopoli)
perche' la seconda dichiarazione fa implicitamente uno shadowing di quella
base (tanto e' vero, pur essendo compilabile, la stessa IDE dovrebbe
segnalarti un warning, sottolineandola)
In sostanza dipende dal risultato che intendi ottenere; puoi fare lo
shadowing, oppure l'override del metodo; in questo secondo caso, dato che
cambi la signature (e' cambiato il tipo di parametro) in realta' devi fare
un overload
In entrambi i casi Paperino non puo' "ereditare direttamente il metodo senza
ridichiararlo", dato che vuoi specificare un tipo di parametro differente;
inoltre se vuoi sfruttare il codice di Personaggio devi espressamente
invocare il metodo della classe base
Una tabellina di comparazione tra shadowing e l'overriding la trovi su MSDN
cercando 'shadowing' (trovi piu' di un link simile, la tabella che intendo
io e' nei "Language Concepts")
Ciao
-- 
Luca Dormio - 
luca....@tin.it
________________________________
"Marty, non stai ragionando in maniera quadridimensionale"
Dr. Emmett L. Brown

 io e' nei "Language Concepts")
Ora controllo.
Grazie, ciao

   e non si lamenta minimamente.
Class Personaggio
    Public Sub VaiA(ByVal destinazione As Citta)
    End Sub
End Class
Class Paperino 'Dim p As Paperino = New Paperino()
    Inherits Personaggio
    Public Overloads Sub VaiA(ByVal destinazione As Paperopoli)
    End Sub
End Class
Eseguendo l'Overloads del metodo ?
giuseppeD

 però non voglio vedere esposto il metodo base.
Hmmm, il new dovrebbe essere la risposta ma genera un warning per via del
parametro diverso... la cosa curiosa e' che se lo ignori compilando
ugualmente, nel codice IL generato trovi
.method public hidebysig instance void  VaiA
               ^^^^^^^^^
cioe' lo stesso che genera VB con la keyword Shadows, che pero' si comporta
come vuoi tu.
Passo la palla a qualche C-ista vero...


 descritto: shadow implicito e warning che me lo segnala
using System;
namespace Test
{
 class Citta : object
 {}
 class Paperopoli : Citta
 {}
 class Topolinia : Citta
 {}
 class Personaggio
 {
  public void VaiA(Citta destinazione)
  {}
 }
 class Paperino : Personaggio
 {
  public void VaiA(Paperopoli destinazione)
  {}
 }
 class Test
 {
  static void Main()
  {
   Paperopoli pap = new Paperopoli();
   Paperino p = new Paperino();
   p.VaiA(pap);


 segnalarti un warning, sottolineandola)
Ok, hai ragione.
Controllando meglio funziona come hai detto :)
Però non capisco una cosa: perchè la classe figlia non ha le proprietà della
genitrice?
Cioè, non è possibile evitare di scrivere
    Public Function Pippo As Long
        Return Base.Pippo
    End Function
Dato che Pippo c'è nella genitrice, me lo aspetterei automaticamente anche
nella figlia.
O non ho capito una mazza?


  }
Che infatti e' il codice che poi avevo riprovato anch'io (mi ero dimenticato
di specificarlo)...
come ti dicevo nell'altro messaggio, in C# si comporta diversamente e fa un
overload, e se aggiungi il new, compilato "di forza", genera lo stesso
attributo 'hidebysig' dell'equivalende Shadow in VB ma non nasconde
comunque... le mie scarse competenze di C si fermano qui...


     End Function
Certo, se no era come l'ereditarieta' "dei poveri" in VB6... se non vuoi
modificarne il comportamento, devi semplicemente evitare di definire la
funzione Pippo nella classe derivata (altrimenti devi anche implementarla)
Esempio classico:
Public Class MyTextBox
    Inherits System.Windows.Forms.TextBox
    Private mMyProp As String
     Public Property MyProp() As String
        Get
            mMyProp = MyProp
        End Get
        Set(ByVal Value As String)
            mMyProp = Value
        End Set
    End Property
End Class
questa classe fa tutto quello che fa un TextBox con una property in piu';
quest'ultima e' l'unica cosa che devi definire.


 funzione Pippo nella classe derivata (altrimenti devi anche implementarla)
Ufff, allora qualcosa non mi funziona.
Ho fatto cosě: definito la classe base con i miei metodi, la classe derivata
senza niente, compilato, passato al reflector per
sicurezza(
http://www.ugidotnet.org/goodies/goodies_categories.aspx
) e questo
mi mostra la classe vuota.
Farň qualche altra prova.
Ciao, grazie ancora.


 mi mostra la classe vuota.
Per l'editing stai usando Visual Studio o altro?
Nel primo caso l'intellisense te la visualizza correttamente?
Riguardo al problema iniziale di nascondere i membri base, guarda un po' se
questo fa al caso tuo:
http://www.ugidotnet.org/tips/tips_read.aspx?ID=122
