Richard/IBKRTrader
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

@

Browse Source 
R2: Generic Host + Modul-Vertrag + Shell-UI (PolytraderSharp-Konzept)

- Core/Modularity: neuer IModule (Name, DbPrefix, RegisterServices(services,config),
  RegisterUi(host,sp), StartAsync/StopAsync, GetActivationBlocker) + ModuleView
  + IModuleUiHost + WindowMenu. Alte IModule/ModuleRegistry/WindowManager/ModuleFormBase entfernt.
- Program.cs: Host.CreateDefaultBuilder + IConfiguration (appsettings.json/.Local.json);
  Core-Services registriert, Module via RegisterServices, Views via RegisterUi.
- UI: ShellUiHost (Einzelinstanz-Fenster + Fenster-Menue), LauncherForm als Shell
  (Buttons je View), Core-Views Logs/Settings/Workers als eigene Fenster.
- CongressTrading auf neuen Vertrag; Worker als IWorker registriert.
- --smoke-ui Headless-Test (konstruiert jede View + Launcher).
- appsettings.Local.json gitignored.
- Tests angepasst -> 30/30 gruen; Build + Smoke-UI + App-Start verifiziert.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
@
This commit is contained in:
Richard
2026-07-28 00:24:00 +02:00
parent c20538c8d8
commit 8f44c0fd82
25 changed files with 695 additions and 1047 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/IBKRTrader.Core/IBKRTrader.Core.csproj
+1
View File
@@ -14,6 +14,7 @@
<PackageReference Include="MySqlConnector" Version="2.4.0" />
<PackageReference Include="Dapper" Version="2.1.35" />
<PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="9.0.4" />
<PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="9.0.4" />
</ItemGroup>
<!-- Erlaubt dem Testprojekt, interne Helfer zu testen. -->
src/IBKRTrader.Core/Modularity/IModule.cs
+43
View File
@@ -0,0 +1,43 @@
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
namespace IBKRTrader.Core.Modularity;
/// <summary>
/// Vertrag für ein IBKRTrader-Modul. Module referenzieren nur den Core, niemals einander.
/// Ein Modul kapselt einen eigenständigen Funktionsbereich (z. B. eine Trading-Strategie)
/// mit eigenen Services, Jobs, DB-Objekten sowie eigenen UI-Ansichten.
///
/// Vorbild: PolytraderSharp <c>IPolyTraderModule</c>.
/// </summary>
public interface IModule
{
/// <summary>Eindeutiger Anzeigename des Moduls, z. B. "CongressTrading".</summary>
string Name { get; }
/// <summary>DB-Präfix für die Objekte des Moduls (z. B. "ct_"), damit sich Module nicht überschneiden.</summary>
string DbPrefix { get; }
/// <summary>
/// Registriert Services/Jobs des Moduls im DI-Container. Wird beim App-Start aufgerufen,
/// bevor der Host gebaut wird.
/// </summary>
void RegisterServices(IServiceCollection services, IConfiguration configuration);
/// <summary>
/// Registriert die UI-Ansichten des Moduls bei der Shell (Launcher). Die Shell öffnet jede Ansicht
/// auf Wunsch in einem eigenen Fenster; Module liefern eigene Forms, die Shell bleibt modul-agnostisch.
/// </summary>
void RegisterUi(IModuleUiHost host, IServiceProvider services);
/// <summary>
/// Optionale Vorab-Prüfung, ob das Modul aktiviert werden kann. Gibt <c>null</c> zurück, wenn
/// aktivierbar, sonst einen kurzen Grund (z. B. „IBKR-Gateway nicht konfiguriert").
/// </summary>
string? GetActivationBlocker(IConfiguration configuration) => null;
/// <summary>Wird nach der Core-Initialisierung gestartet (kein Anlaufen gegen leeren State).</summary>
Task StartAsync(CancellationToken cancellationToken);
Task StopAsync(CancellationToken cancellationToken);
}
src/IBKRTrader.Core/Modularity/ModuleView.cs
+57
View File
@@ -0,0 +1,57 @@
using System.Windows.Forms;
namespace IBKRTrader.Core.Modularity;
/// <summary>
/// Eine vom Core oder einem Modul beigesteuerte Fenster-Ansicht. Die eigentliche UI ist ein
/// <see cref="Form"/>, das über <see cref="CreateForm"/> erzeugt wird (mit DI-Abhängigkeiten).
/// Die Shell zeigt je View höchstens eine Instanz und holt ein offenes Fenster wieder nach vorne.
/// </summary>
public sealed class ModuleView
{
/// <summary>Stabile ID für Einzelinstanz-Handling (nur ein Fenster je View).</summary>
public string Id { get; init; } = Guid.NewGuid().ToString();
/// <summary>Titel (Fallback-Fenstertitel, falls das Form keinen eigenen setzt).</summary>
public string Title { get; init; } = "Fenster";
/// <summary>Optionale Gruppierung (z. B. "Core", "CongressTrading").</summary>
public string? Group { get; init; }
/// <summary>Optionale Sortierreihenfolge in Menü/Buttons.</summary>
public int Order { get; init; } = 0;
/// <summary>Optionales Icon für Menü/Buttons.</summary>
public System.Drawing.Image? Icon { get; set; }
/// <summary>Erzeugt das anzuzeigende Fenster (frische Instanz je Öffnung).</summary>
public Func<Form> CreateForm { get; init; } = () => new Form();
}
/// <summary>
/// Wird der Shell beim Start übergeben; Core und Module registrieren hier ihre Ansichten.
/// Über die Navigations-Mitglieder kann JEDES Fenster (auch Modul-Fenster, die nur den Core kennen)
/// das gemeinsame „Fenster"-Menü bauen (siehe <see cref="WindowMenu"/>).
/// </summary>
public interface IModuleUiHost
{
void RegisterView(ModuleView view);
/// <summary>Alle registrierten Ansichten (Core + Module).</summary>
IReadOnlyList<ModuleView> Views { get; }
/// <summary>Ist das Fenster dieser View gerade offen?</summary>
bool IsOpen(string viewId);
/// <summary>Öffnet die View bzw. holt ein bereits offenes Fenster in den Vordergrund.</summary>
void OpenView(string viewId);
/// <summary>Holt das Hauptfenster (Launcher) in den Vordergrund.</summary>
void ActivateMain();
/// <summary>Leitet das (bestätigte) Herunterfahren der App ein. Aus jedem Fenster aufrufbar.</summary>
void RequestShutdown();
/// <summary>Feuert, wenn sich der Offen-Status irgendeiner View ändert.</summary>
event Action? OpenStateChanged;
}
src/IBKRTrader.Core/Modularity/WindowMenu.cs
+79
View File
@@ -0,0 +1,79 @@
using System.Drawing;
using System.Windows.Forms;
namespace IBKRTrader.Core.Modularity;
/// <summary>
/// Baut das gemeinsame Fenster-Menü, das auf JEDEM Fenster erscheint und das Wechseln zwischen allen
/// Fenstern (Launcher + Core + Module) erlaubt. Da es nur den Core-Contract <see cref="IModuleUiHost"/>
/// nutzt, funktioniert es auch aus Modul-Fenstern (die die App nicht kennen).
/// </summary>
public static class WindowMenu
{
/// <summary>
/// Verdrahtet einen <see cref="MenuStrip"/> mit der Fensterliste: füllt ihn sofort und baut ihn bei
/// jeder Offen-Status-Änderung neu auf. Die Registrierung wird beim Entsorgen sauber gelöst.
/// </summary>
public static void Wire(MenuStrip menu, IModuleUiHost host, string? currentViewId)
{
void Refresh()
{
if (menu.IsDisposed) return;
if (menu.IsHandleCreated && menu.InvokeRequired)
{
try { menu.BeginInvoke((Action)(() => Populate(menu, host, currentViewId))); }
catch { /* Fenster wird gerade geschlossen */ }
return;
}
Populate(menu, host, currentViewId);
}
Populate(menu, host, currentViewId);
host.OpenStateChanged += Refresh;
menu.Disposed += (_, _) => host.OpenStateChanged -= Refresh;
}
/// <summary>Baut die Menüleiste komplett neu auf (Launcher, alle Views nebeneinander, Aktion rechts).</summary>
public static void Populate(MenuStrip menu, IModuleUiHost host, string? currentViewId)
{
menu.Items.Clear();
var launcher = new ToolStripMenuItem("Launcher") { Checked = currentViewId == null };
if (currentViewId == null) launcher.Font = new Font(launcher.Font, FontStyle.Bold);
launcher.Click += (_, _) => host.ActivateMain();
menu.Items.Add(launcher);
foreach (var view in host.Views.OrderBy(v => v.Order).ThenBy(v => v.Title))
{
bool isCurrent = view.Id == currentViewId;
var item = new ToolStripMenuItem(view.Title)
{
Image = view.Icon,
ImageScaling = ToolStripItemImageScaling.SizeToFit,
DisplayStyle = view.Icon != null
? ToolStripItemDisplayStyle.ImageAndText
: ToolStripItemDisplayStyle.Text,
Checked = isCurrent || host.IsOpen(view.Id)
};
if (isCurrent) item.Font = new Font(item.Font, FontStyle.Bold);
string id = view.Id;
item.Click += (_, _) => host.OpenView(id);
menu.Items.Add(item);
}
// Kontextabhängige rechte Aktion: nur der Launcher darf die App beenden; jedes andere Fenster
// bietet nur „Fenster schließen" (kein App-Shutdown, Module laufen weiter).
if (currentViewId == null)
{
var exit = new ToolStripMenuItem("Beenden") { Alignment = ToolStripItemAlignment.Right };
exit.Click += (_, _) => host.RequestShutdown();
menu.Items.Add(exit);
}
else
{
var close = new ToolStripMenuItem("Fenster schließen") { Alignment = ToolStripItemAlignment.Right };
close.Click += (_, _) => menu.FindForm()?.Close();
menu.Items.Add(close);
}
}
}
src/IBKRTrader.Core/Modules/IModule.cs
-44
View File
@@ -1,44 +0,0 @@
using IBKRTrader.Core.Workers;
using Microsoft.Extensions.DependencyInjection;
namespace IBKRTrader.Core.Modules;
/// <summary>
/// Vertrag für ein eigenständiges Trading-Modul.
///
/// Architektur-Regel: Der Core kennt konkrete Module NICHT. Module hängen sich
/// ausschließlich über diesen Vertrag und den DI-Container ein
/// (Abhängigkeit nur Modul → Core, niemals umgekehrt).
///
/// Lebenszyklus:
/// 1. <see cref="RegisterServices"/> – vor dem Bauen des DI-Containers
/// 2. <see cref="InitializeAsync"/> – beim App-Start (Migrationen etc.)
/// 3. <see cref="GetWorkers"/> – Worker werden der WorkerEngine übergeben
/// 4. <see cref="CreateWindow"/> – Launcher öffnet das Modul-Fenster
/// </summary>
public interface IModule
{
/// <summary>Eindeutiges Modul-Kürzel, zugleich DB-Tabellen-Präfix (z. B. "CT").</summary>
string Key { get; }
/// <summary>Anzeigename im Launcher (z. B. "Congress Trading").</summary>
string DisplayName { get; }
/// <summary>Kurzbeschreibung der Strategie für den Launcher.</summary>
string Description { get; }
/// <summary>Modul-Version.</summary>
string Version { get; }
/// <summary>Registriert alle Modul-Services im DI-Container (vor dem Build).</summary>
void RegisterServices(IServiceCollection services);
/// <summary>Führt Modul-Migrationen und einmalige Initialisierung aus (beim Start).</summary>
Task InitializeAsync(IServiceProvider provider);
/// <summary>Liefert die Worker/Services des Moduls für die WorkerEngine.</summary>
IEnumerable<IWorker> GetWorkers(IServiceProvider provider);
/// <summary>Erzeugt das eigenständige Fenster des Moduls (vom Launcher geöffnet).</summary>
Form CreateWindow(IServiceProvider provider);
}
src/IBKRTrader.Core/Modules/ModuleRegistry.cs
-22
View File
@@ -1,22 +0,0 @@
namespace IBKRTrader.Core.Modules;
/// <summary>
/// Zentrale Registry aller geladenen Module.
/// Wird in Program.cs mit den Modul-Instanzen befüllt und als Singleton
/// bereitgestellt, damit Launcher und Startup-Code über die Module iterieren
/// können, ohne konkrete Modultypen zu kennen.
/// </summary>
public class ModuleRegistry
{
private readonly List<IModule> _modules;
public ModuleRegistry(IEnumerable<IModule> modules)
=> _modules = modules?.ToList() ?? throw new ArgumentNullException(nameof(modules));
/// <summary>Alle registrierten Module in Registrierungsreihenfolge.</summary>
public IReadOnlyList<IModule> Modules => _modules;
/// <summary>Findet ein Modul anhand seines Kürzels (case-insensitive) oder null.</summary>
public IModule? Find(string key)
=> _modules.FirstOrDefault(m => string.Equals(m.Key, key, StringComparison.OrdinalIgnoreCase));
}
src/IBKRTrader.Core/Ui/ModuleFormBase.cs
-25
View File
@@ -1,25 +0,0 @@
namespace IBKRTrader.UI;
/// <summary>
/// Basisklasse für eigenständige Modul-Fenster.
/// Stellt gemeinsame Grundeinstellungen (Größe, Startposition) bereit und
/// hält den Modul-Key, damit der Launcher/WindowManager das Fenster zuordnen kann.
/// </summary>
public class ModuleFormBase : Form
{
/// <summary>Kürzel des zugehörigen Moduls (z. B. "CT").</summary>
public string ModuleKey { get; }
// Parameterloser Ctor nur für den WinForms-Designer.
protected ModuleFormBase() : this("") { }
protected ModuleFormBase(string moduleKey)
{
ModuleKey = moduleKey;
Width = 900;
Height = 600;
StartPosition = FormStartPosition.CenterScreen;
ShowInTaskbar = true;
MinimumSize = new Size(600, 400);
}
}
src/IBKRTrader.Core/Ui/WindowManager.cs
-82
View File
@@ -1,82 +0,0 @@
namespace IBKRTrader.UI;
/// <summary>
/// Verwaltet die eigenständigen Modul-Fenster des Launchers.
/// Pro Modul-Key wird höchstens ein Fenster gehalten: erneutes Öffnen
/// fokussiert das bestehende Fenster statt ein zweites zu erzeugen.
///
/// Die tatsächlichen UI-Aktionen (Show/Focus) sind in überschreibbare
/// Methoden gekapselt, damit die Tracking-Logik ohne Message-Loop testbar ist.
/// </summary>
public class WindowManager
{
private readonly Dictionary<string, Form> _open = new(StringComparer.OrdinalIgnoreCase);
/// <summary>Öffnet das Fenster zum Key oder fokussiert ein bereits offenes.</summary>
public Form OpenOrFocus(string key, Func<Form> factory)
{
ArgumentException.ThrowIfNullOrWhiteSpace(key);
ArgumentNullException.ThrowIfNull(factory);
if (_open.TryGetValue(key, out var existing))
{
if (!existing.IsDisposed)
{
Focus(existing);
return existing;
}
_open.Remove(key);
}
var form = factory();
_open[key] = form;
form.FormClosed += OnFormClosed;
Present(form);
return form;
}
/// <summary>True, wenn zum Key aktuell ein nicht-disposetes Fenster offen ist.</summary>
public bool IsOpen(string key)
=> _open.TryGetValue(key, out var f) && !f.IsDisposed;
/// <summary>Anzahl aktuell offener Fenster.</summary>
public int OpenCount => _open.Values.Count(f => !f.IsDisposed);
/// <summary>Schließt alle offenen Fenster (z. B. beim Beenden des Launchers).</summary>
public void CloseAll()
{
foreach (var f in _open.Values.ToList())
{
if (!f.IsDisposed)
{
f.FormClosed -= OnFormClosed;
f.Close();
}
}
_open.Clear();
}
// ─── Überschreibbare UI-Aktionen (für Tests) ──────────────────────────────
/// <summary>Zeigt ein neu erzeugtes Fenster an.</summary>
protected virtual void Present(Form form) => form.Show();
/// <summary>Bringt ein bestehendes Fenster in den Vordergrund.</summary>
protected virtual void Focus(Form form)
{
if (form.WindowState == FormWindowState.Minimized)
form.WindowState = FormWindowState.Normal;
form.Activate();
form.BringToFront();
}
private void OnFormClosed(object? sender, FormClosedEventArgs e)
{
if (sender is not Form f) return;
f.FormClosed -= OnFormClosed;
var entry = _open.FirstOrDefault(p => ReferenceEquals(p.Value, f));
if (entry.Key is not null)
_open.Remove(entry.Key);
}
}