Qual è il modo migliore per avere 2 classi ereditate che condividono la stessa classe base ma un'interfaccia diversa?

Question

Qual è il modo migliore per avere 2 classi ereditate che condividono la stessa classe base ma un'interfaccia diversa?

#1 da (0 voti)

-1

Non sono riuscito a trovare un titolo migliore. Proverò a spiegare qual è il problema.

Attualmente sto cercando di creare una struttura di report creata dinamicamente. Definisco il rapporto necessario nel file di configurazione. Quando l'utente vuole un report, semplicemente analizzo da config e create. La mia lotta è su come posso implementare una struttura generale, ma riguarda i campi aggiuntivi forniti dalle interfacce.

Nell'immagine puoi vedere il diagramma delle classi. Quello che voglio è che voglio usare ReportStore per memorizzare tutti i report condivisi ed estesi e fornire quando necessario. Tuttavia in ReportStore quando l'utente chiama GetReportByName(reportName) Ho bisogno di restituire un ReportObject . Questo oggetto può essere SharedReport o ExtensiveReport .

L'uso di ISharedReport per il valore restituito causerà la perdita di un campo aggiuntivo negli oggetti basato su IExtensiveReport .
Se voglio restituire IExtensiveReport , verrà violato.
Se voglio restituire un oggetto semplice e lanciare in ReportComposer in base al tipo di valore, sarà complesso e non adatto agli sviluppatori.

Sono aperto a suggerimenti. Grazie in anticipo

programming-practices design-patterns

posta omer faruk 15.09.2017 - 11:51

fonte

1 risposta

Leggi altre domande sui tag programming-practices design-patterns

Come scrivere un'interfaccia Python libera in cui le sottoclassi possono aggiungere dati extra? Posso utilizzare ASP.net MVC 5 per creare un'applicazione per pagina singola senza alcun framework front-end?

score 0 · Answer 1

Se ti capisco bene, di recente ho affrontato un problema simile e l'ho risolto in questo modo (non che io ritenga che questo sia necessariamente il modo migliore per farlo) (Nota C # -ish codice avanti)

IBaseReport
{
   ReportTypeEnum ReportType { get; }
   // Other common stuff EG
   Print() ..
   GetDetails() ..
}

ISharedReport : IBaseReport
{
  // Shared report only stuff
}

IExtensiveReport : IBaseReport
{
  // Extensive report only stuff
}

abstract class BaseReport
{
  ReportTypeEnum ReportType { get; private set; }
}

class ExtensiveReport : BaseReport, IExtensiveReport
{
  public SharedReport()
  {
     ReportType = ReportTypeEnum.Extensive;
  }
}


class SharedReport : ExtensiveReport, ISharedReport
{
  public SharedReport() 
  {
     ReportType = ReportTypeEnum.Shared;
  }
}



List<IBaseReport> DataStore = new List<IBaseReport>();
DataStore.Add(new ExtensiveReport());
DataStore.Add(new SharedReport());
etc ..

var report1 = DataStore[0];
report1.Print();

var report2 = DataStore[1] as ISharedReport;
if (report2 != null)
{
  // do SharedReport specific stuff
}

E poi memorizzo / restituisco solo IBaseReport oggetti. Questi oggetti sanno di che tipo sono, quindi non è necessario trasferirli a qualcosa quando li usi tramite l'interfaccia comune. Ma se hai bisogno di funzionalità specifiche per classe puoi tranquillamente eseguire il cast sull'interfaccia richiesta ( ISharedReport o IExtensiveReport oggetti) e se l'oggetto non supporta quell'interfaccia il tuo meccanismo di casting te lo consente di sapere - tuttavia se l'interfaccia di base è è sufficiente che non sia necessario eseguire il cast.