Ultimo messaggio

nero.mancini

il 15 dicembre 2011 alle 15:04

19 messaggi dal 15 marzo 2011

Salve, avrei bisogno di creare - diciamo cosi' - una struttura generica in cui io possa implementare via via delle classi che specializzino tale "struttura".
Provo a spiegarmi meglio postando dove ero arrivato fin'ora..

Ho bisogno di una classe astratta o un interfaccia (conosco la differenza) tipo la seguente:

public abstract class BaseService
{
  public abstract int id { get; set; }

  public abstract CommonData commonData { get; set; }
}
public abstract class CommonData
{
  public virtual string aa { get; set; }
  public virtual string bb { get; set; }
}

che poi venga specializzata da classi successive tipo la seguente:

public class OneClass : BaseService
{
  public override int id { get; set; }

  public override CommonData commonData { get; set; }

  public class OneClassCommonData : CommonData
  {
    public override string aa { get; set; }
    public override string bb { get; set; }
    public string cc { get; set; }

    public OneClassCommonData()
    {
    }
  }

  public OneClass() : base()
  {
    commonData = new OneClassCommonData();
  }
}

In modo da poter fare nel Main qualosa tipo:

OneClass one = new OneClass();
onr.commonData.cc = "eccolo";

Ho provato anche a vedere i DesignPattern della GangOfFour ma non ne trovo nessuno che faccia al caso mio
Grazie

Rispondi Quoting

nero.mancini

il 15 dicembre 2011 alle 22:39

19 messaggi dal 15 marzo 2011

Nessun suggerimento?

Rispondi Quoting

BrightSoul

il 15 dicembre 2011 alle 23:14

5.610 messaggi dal 09 febbraio 2002
Contributi

Ciao, qui trovi un articolo sull'ereditarietà
http://msdn.microsoft.com/it-it/library/ms173149.aspx

Non conosco la situazione in cui ti trovi quindi potrei sbagliarmi ma... non sarebbe possibile fare a meno di creare la classe "CommonData"?
Potresti definire le proprietà "aa", "bb" e "id" subito all'interno di "BaseService" e te le troveresti già disponibili nella classe "OneClass" che da essa eredita. Esempio, qui definisco la classe base:

//uso abstract solo se non voglio che BaseService si possa istanziare 
public abstract class BaseService{
  public int id {get; set;}
  public string aa { get; set; }
  public string bb { get; set; }
}

Nota come non abbia usato il modificatore abstract per i membri di BaseService. Infatti non vale la pena di usarlo a meno che tu non voglia che le sottoclassi debbano obbligatoriamente fornire una loro implementazione per quelle semplici proprietà. Potresti usare il modificatore virtual, casomai, per fare in modo che le sottoclassi, opzionalmente e a loro piacimento, possano farne l'override.

Quindi puoi definire una sottoclasse e farla ereditare da BaseService

public class OneClass : BaseService
{
    public string cc { get; set; }
}

Il codice è semplice, ho dovuto solo aggiungere una nuova proprietà "cc", dato che OneClass già eredita i membri "aa", "bb" e "id" da BaseClass.

Allo stesso modo posso creare altre classi come "TwoClass" o "ThreeClass". Grazie al polimorfismo, tutte quante potranno essere ricondotte a BaseService.

var one = new OneClass();
var base = one as BaseService; //polimorfismo

Ciò, ad esempio, mi consente di aggiungere delle istanze di OneClass, TwoClass e ThreeClass ad un'unica lista perché tutte condividono il tipo base BaseService.

var lista = new List<BaseService>(){
  new OneClass(),
  new TwoClass(),
  new ThreeClass()
};

Ho risposto alla tua richiesta?

- So what you're saying is, if we get in trouble, there's no one to help us out?
- I'm afraid not.
- Fantastic!

Rispondi Quoting

nero.mancini

il 16 dicembre 2011 alle 00:46

19 messaggi dal 15 marzo 2011

Ciao, intanto grazie per la l'aiuto.
Abbi pazienza: il mio post, letto a posteriori, effettivamente non rende l'idea della mia richiesta.

Provo a spiegarmi con un esempio piu' parlato.
Metti che tu "costruisci" notebook e cellulari.

Vuoi che questi oggetti abbiano delle caratteristiche comuni, che puoi raggruppare logicamente in (sotto)classi, e vuoi che quando costruirai un tipo nuovo (es palmari o tablet) ti basti ereditare/implementare da un unica entita' le caratteristiche comuni per poi aggiungere delle caratteristiche piu' specifiche a completamento.

Quindi intendo qualcosa tipo (lasciando perdere un attimo la sintassi):

public abstract class OggBase
{
   public abstract InputBase
   public abstract OutputBase
}
 public abstract class InputBase
 {
    public abstract tastiera
 }
 public abstract class OutputBase
 {
    public abstract altoparlanti
    public abstract schermo
 }

Cosi' per notebook potrai fare:

public class Notebook : OggBase
{
  public class InputNotebook : InputBase
  {
     public tastiera
     public mouse   //caratteristica specifica x notebook
  }
  public class OutputNotebook : OutputBase
  {
     public altoparlanti
     public schermo
     public stampante    //caratteristica specifica x notebook
  }
}

Mentre per cellulare potrai fare:

public class Cellulare : OggBase
{
  public class InputCellulare : InputBase
  {
     public tastiera
     public comandi_vocali   //caratteristica specifica x cellulari
  }
  public class OutputCellulare : OutputBase
  {
     public altoparlanti
     public schermo
     public telefonate    //caratteristica specifica x cellulari
  }
}

Il mio problema e' che nel Main chiaramente avrei:

Notebook pippo = new Notebook();
  pippo.InputNotebook.tastiera            //lo vedo
  pippo.InputNotebook.mouse               //non lo vedo
  pippo.OutputNotebook.altoparlanti       //lo vedo
  pippo.OutputNotebook.schermo            //lo vedo
  pippo.OutputNotebook.stampante          //non lo vedo

e parallelamente per i cellulari

Cellulare pluto = new Cellulare();
  pluto.InputCellulare.tastiera            //lo vedo
  pluto.InputCellulare.comandi_vocali      //non lo vedo
  pluto.OutputCellulare.altoparlanti       //lo vedo
  pluto.OutputCellulare.schermo            //lo vedo
  pluto.OutputCellulare.telefonate         //non lo vedo

Il "codice" che ho scritto sopra e' puramente indicativo poiche' segue la strada (errata) che stavo iniziando a percorrere - quindi immagino che dovra' essere data tutt'altra impostazione.

Grazie 1000

Rispondi Quoting

fileman

il 16 dicembre 2011 alle 09:47

1.058 messaggi dal 02 ottobre 2006
Contributi
www.filardo.it

mi sono un pò perso nel discorso....

Cellulare : OggBase, ICellulare{
base:method....

telefonate(){
...
}
}

ICellulare {
public telefonate
}

se una caratteristica è comune a "cellulari" e "tablet", potresti fare
MobileDevice : OggBase{
caratteristica comune dispositivi mobili
}
e
Cellulare : MobileDevice, ICellulare

Modificato da fileman il 16 dicembre 2011 10.03 -

jQuery & Azure ... come ho fatto a stare senza fin'ora!

Non hai veramente capito qualcosa fino a quando non sei in grado di spiegarlo a tua nonna.
-Albert Einstein-

Rispondi Quoting

nero.mancini

il 16 dicembre 2011 alle 10:33

19 messaggi dal 15 marzo 2011

Scusami, non ho ben capito cosa vuoi dire.
Riesci a darmi un po piu' di dettaglio?
Grazie

Rispondi Quoting

fileman

il 16 dicembre 2011 alle 11:10

1.058 messaggi dal 02 ottobre 2006
Contributi
www.filardo.it

ho fatto un esempio di quello che volevo dire, se non ho capito male, funziona.

jQuery & Azure ... come ho fatto a stare senza fin'ora!

Non hai veramente capito qualcosa fino a quando non sei in grado di spiegarlo a tua nonna.
-Albert Einstein-

Rispondi Quoting

nero.mancini

il 16 dicembre 2011 alle 12:02

19 messaggi dal 15 marzo 2011

Si ok, ho "studiato" il tuo esempio, del quale ti ringrazio.

Quello che mi occorrerebbe e' utilizzare il solo OggBase da far ereditare a Notebook. Quindi in questo senso IInputBase e IOutputBase (oppure InputBase e OutputBase se vuoi) dovrebbero in qualche modo essere "dentro" OggBase.
Tant'e' che InputBase e OutputBase non vengono mai utilizzati nell'esempio.

Io avrei trovato questa semi-soluzione:

    public abstract class OggBase
    {
        public abstract int id { get; set; }
        protected abstract InputBase inputBase { get; set; }
    }
    public abstract class InputBase
    {
        public virtual string tastiera { get; set; }
    }

    public class Notebook : OggBase
    {
        public override int id { get; set; }

        protected override InputBase inputBase { get; set; }
        public NotebookInputBase notebookInputBase { get; set; }

        public class NotebookInputBase : InputBase
        {
            public override string tastiera { get; set; }
            public string mouse { get; set; }
        }

        public Notebook() : base()
        {
            inputBase = new NotebookInputBase();

            notebookInputBase = (NotebookInputBase)inputBase;
        }
     }

e in questo modo potrei accedere a:

Notebook mioNotebook = new Notebook();
mioNotebook.inputBase.tastiera = "boh 1";      //non lo vedo
mioNotebook.notebookInputBase.mouse = "beh 2";      //questo invece lo vedo..

L'unica cosa che non mi piace e' che dovrei ogni volta "inventarmi" un aggeggio tipo NotebookInputBase (ovvero CellulareInputBase) e poi fare il cast... e non e' bellissimo: secondo te si riesce a ottimizzare questa soluzione?
Grazie 1000

Rispondi Quoting

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.

Community

Ultimi messaggi

UTENTI ONLINE