C#, Entwurfsmuster für Containerklassen?

Question

Ich habe mich in C# vertieft, bin aber auf ein Problem gestoßen, das ich nicht zu lösen scheine:

Ich habe eine Finanz-Backtest- und Trading-Engine entwickelt, und als Teil davon möchte ich einen "Strategie-Container" implementieren. Dieser Strategie-Container sollte zwei Zwecke erfüllen. (1) Instanzen verschiedener Strategien enthalten, die mathematische Berechnungen durchführen, und (2) Accessors bereitstellen, um neue Tickdaten in die Strategieinstanzen zu übertragen und bestimmte Informationen von den Strategieinstanzen zurückzuerhalten.

Die verschiedenen Strategien, die ich oben erwähnt habe, sollten eigenständige Klassen sein, die jedoch von einer Basisklasse abgeleitet sind. Ich möchte innerhalb dieser Strategien völlig unterschiedliche Operationen durchführen, daher dachte ich, dass es machbar wäre, sie als separate Klassen zu entwerfen, die von einer Basisklasse abgeleitet sind. Eine Komplikation besteht darin, dass ich mehrere Instanzen jeder Strategieklasse benötige, die im Strategiecontainer enthalten ist. Jede Strategieklasse enthält auch eine Liste von Aktiensymbolen, und jedes Symbol sollte eine eigene Strategieinstanz erhalten.

Ein weiterer wichtiger Punkt des Strategie-Containers ist, dass er jede Strategieinstanz erstellen, instanziieren und später auch aufrufen kann.

Ich wollte einige von Ihnen fragen, welche Ideen Sie haben, wie ich dies gestalten und umsetzen könnte:

• Was wäre das beste Entwurfsmuster überhaupt?
• wie beschrieben, wenn ich verschiedene Klassen für jede Strategie erstellen, dann würde ich offensichtlich am Ende mit verschiedenen Typen als auch, wie könnte ich alle diese in einem Container/Sammlung innerhalb der Strategie-Container halten?
• Wie kann ich entweder durch Reflexion oder mit anderen Mitteln Methoden für jede einzelne Strategieinstanz erstellen, instanziieren und aufrufen, ohne zu wissen, wie viele ich am Ende haben werde? Ich kenne die Namen und Typen der Strategien und ich kenne die Namen der Aktiensymbole.
• Ich möchte lediglich angeben, welche Strategien ich einbinden möchte (ich gebe die Strategienamen = Klassennamen?) und für jede Strategie eine Liste von Aktiensymbolen. Der Strategie-Container würde Instanzen für jedes Symbol in jeder Strategie des Strategietyps erstellen, für den die Liste geliefert wurde, und würde anschließend eine "RunStrategy(Quote quote)"-Methode aufrufen, die neue Kurse in jede Instanz einspeist, damit Berechnungen durchgeführt werden können.
• Ein Ziel wäre es, die Schnittstelle jeder Strategieklasse so sauber wie möglich zu halten, wobei die meisten (sich wiederholenden) Standardfunktionen in der von der Basisklasse abgeleiteten Klasse implementiert werden.

Ich bitte nicht um vollständigen Quellcode, sondern um Ideen, wie ich das Ding gestalten sollte und wie ich jeden der oben genannten Punkte erreichen könnte. Dies ist etwas für mich selbst und wird nicht zu einem kommerziellen Produkt werden. Ich bin sehr vertraut mit dem Schreiben von Code, der die mathematischen Bits und Stücke implementiert, aber ich bin weniger vertraut mit Design Patterns und Systemarchitektur.

Bearbeiten: Graymatter, ich habe ein wenig herumgespielt und es scheint, dass Sie genau das geliefert haben, wonach ich gesucht habe. Danke vielmals.

class Program
{
    static void Main(string[] args)
    {
        List<IStrategy> container = new List<IStrategy>();

        container.Add(new StrategyOne());

        container[0].AddValue(50);

        Console.ReadLine();
    }

}

public interface IStrategy
{
    void AddValue(int value);  
}

public class StrategyOne : StrategyBase
{
    public override void Calculates()
    {
        Console.WriteLine("This is my value: " + myValue);
    }

}

public class StrategyBase : IStrategy
{
    protected int myValue;

    public void AddValue(int value)
    {
        Console.WriteLine("Run Strategy in Base");

        myValue = value;

        Calculates();
    }

    public virtual void Calculates()
    {

    }  
}

Answer 1

Für diese Art von System sollten Sie wirklich die Verwendung von Schnittstellen in Betracht ziehen. Die Schnittstelle ist Ihr Vertrag mit der Strategie, und Sie können eine beliebige Anzahl von verschiedenen Implementierungen für die Schnittstelle verwenden. Ihr Container würde dann Schnittstellen enthalten.

Etwa so:

public interface IStrategy
{
  void RunStrategy(Quote quote);
}

Dann würden Ihre Implementierungen etwa so aussehen:

public class StrategyOne : IStrategy
{
  void RunStrategy(Quote quote)
  {
  }
}

Der Container könnte sein:

List<IStrategy> container = new List<IStrategy>();

Answer 2

Nun, Design sollte auftauchen aus der Anforderungsanalyse/Crunching. Ich würde nicht einfach beschließen, dieses oder jenes Muster zu verwenden, und dann versuchen zu sehen, wie es in den Bereich passt.

von einer Basisklasse ableiten

Auch dies muss durch die gemeinsame Funktionalität, die von der Basisklasse ausgeführt werden soll, gerechtfertigt sein, andernfalls ist eine Schnittstelle alles, was Sie brauchen. Das Strategiemuster wird durch eine gemeinsame Schnittstelle definiert, bei der alle Strategien auf eine gemeinsame Datenstruktur zugreifen.

Ich empfehle daher, jegliche Vorurteile über das Design aufzugeben und sich voll und ganz auf die Anforderungen und die Modellierung Ihres Bereichs zu konzentrieren. Daraus wird sich ein gutes Design ergeben.