[Architektur] Wie definiert man ein Interface, welches ein anderes Interface aufrufen soll

Seikilos

Hallo,

ich bin gerade über eine Frage gestolpert, bei der ich mir nicht sicher bin, wie man die Sinnvoll löst.

Wenn man zwei Interfaces hat, aus der Luft gegriffen sehen die so aus:

// virtuelle dtors und scope mal außen vor
class IManager
{
  virtual void DoWork(Item*) = 0;
};

class IWorkHandler
{
  virtual void ProcessChunk(Chunk *) = 0;
};

So würde ich gerne noch explizit das Konzept einbringen, dass IManager::DoWork irgendwann explizit IWorkHandler::ProcessChunk aufrufen soll.

Wie drücke ich das aus? Eine konkrete Implementierung kann vom IManager::DoWork kann ja machen was sie will, auch den IWorkHandler ignorieren.

Danke

knivil

Wie drücke ich das aus?

Im Datentyp, in der Dokumentation oder als Template.

Seikilos

Hallo,

was meinst du mit im Datentyp ausdrücken?

Jester

Du könntest zum Beispiel eine default-Implementierung der Methode bereitstellen, die kann der Benutzer dann ja nach belieben überschreiben bzw. aufrufen.

Skym0sh0

wie wärs mit dem Template-Method-Pattern?

Du schreibst eine nicht virtuelle Methode, mit diesem Namen (in dem Fall DoWork), diese ruft ProcessChunk auf und danach eine weitere virtuelle Methode, die der User überschreiben kann/soll/muss.

So hast du die Garantie, dass deine Methode aufgerufen wird, der User kann aber sein eigenes Süppchen kochen.

class IManager
{
  void DoWork(Item*)
  {
	IWorkHandler iw = ...;
	iw.ProcessChunk(...);
	this->DoWork_(...);
  }

protected:
  void DoWork_(Item*) = 0;
};

class IWorkHandler
{
  virtual void ProcessChunk(Chunk *) = 0;
};

Seikilos

Stimmt.
Allerdings habe ich das Problem dass ProcessChunk in der Mitte von DoWork aufgerufen wird. In DoWork muss erst noch der Kontext für ProcessChunk bereit gestellt werden.
Und das Bereitstellen würde in dem Fall eine konkrete IManager Klasse machen müssen.

Es ist so für mich schwierig zu sagen, zu welchem Zeitpunkt ProcessChunk in DoWork aufgerufen werden soll.

Shade Of Mine

Mehr infos.

Ansonsten sage ich Skym0sh0s Template Method klingt gut.
Template Method kann auch aus mehr als 1 virtuellen Methode bestehen...

Seikilos

Eine konkrete Manager Klasse könnte so aussehen:

class Manager1
{
void DoWork(..)
{
  // Init
  // Create
  handler->ProcessChunk();
}
};

oder auch

class Manager1
{
void DoWork(..)
{
  handler->ProcessChunk();
  // Use results

}
};

oder

class Manager1
{
void DoWork(..)
{
  // For n objects do
  handler->ProcessChunk();

  // Cleanup

}
};

Da fände ich es schwierig vorweg zu sagen, zu welchem Zeitpunkt das ProcessChunk aufgerufen werden soll.

cooky451

Woher kommt eigentlich der Chunk? Ansonsten würde ich es entweder so lassen wie am Anfang, oder eine nicht virtuelle public Methode und zwei private virtuelle Methoden schreiben, die dann aufgerufen werden. (Dazwischen wird ProcessChunk gesetzt.)

Wozu braucht man diesen IManager als Interface?