Phase 5-UI (Fundament): Modul-UI-Contract im Core (Launcher-Modell)

- IPolyTraderModule um RegisterUi(IModuleUiHost) erweitert.
- Neu: IModuleUiHost + ModuleView (Core, Modularity) — Views sind designbare
  Controls (UserControls), die die Shell in eigenständigen Host-Fenstern öffnet.
- Core: UseWindowsForms aktiviert (fuer den Control-Typ im Contract).
- Build 0 Fehler. Noch keine View implementiert (folgt view-fuer-view).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/PolyTrader.Core/Modularity/IPolyTraderModule.cs

@@ -8,12 +8,7 @@ namespace PolyTrader.Core.Modularity
     /// <summary>
     /// Vertrag für ein PolyTrader-Modul. Module referenzieren nur den Core, niemals
     /// einander. Ein Modul kapselt einen eigenständigen Funktionsbereich (z.B. Copytrading)
-    /// mit eigenen Services, Jobs, DB-Objekten und – ab Phase 5 – eigenen UI-Tabs und
+    /// mit eigenen Services, Jobs, DB-Objekten sowie eigenen UI-Ansichten und Settings-Sektionen.
-    /// Settings-Sektionen.
-    ///
-    /// Hinweis: Der UI-Beitrag (RegisterUi/IModuleUiHost) wird in Phase 5 ergänzt, sobald
-    /// die konkrete UI-Integration (Tabs + Settings-Sektion) feststeht. Bis dahin deckt der
-    /// Contract Lebenszyklus und Service-Registrierung ab.
     /// </summary>
     public interface IPolyTraderModule
     {
@@ -32,6 +27,13 @@ namespace PolyTrader.Core.Modularity
         /// </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 Host-Fenster. Module liefern designbare
+        /// UserControls; die Shell bleibt modul-agnostisch.
+        /// </summary>
+        void RegisterUi(IModuleUiHost host);
+
         /// <summary>Wird nach der Core-Hydration gestartet (kein Anlaufen gegen leeren State).</summary>
         Task StartAsync(CancellationToken cancellationToken);
 

src/PolyTrader.Core/Modularity/ModuleUi.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Windows.Forms;
+
+namespace PolyTrader.Core.Modularity
+{
+    /// <summary>
+    /// Eine vom Core oder einem Modul beigesteuerte UI-Ansicht. Die Shell entscheidet,
+    /// wie sie präsentiert wird (aktuell: eigenständiges Host-Fenster über den Launcher).
+    /// Die eigentliche UI ist ein designbares <see cref="Control"/> (i.d.R. ein UserControl),
+    /// das über <see cref="CreateControl"/> erzeugt wird (mit DI-Abhängigkeiten).
+    /// </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 für Launcher-Eintrag und Fenstertitel.</summary>
+        public string Title { get; init; } = "View";
+
+        /// <summary>Optionale Gruppierung im Launcher (z.B. "Core", "CopyTrading").</summary>
+        public string? Group { get; init; }
+
+        /// <summary>Optionale Sortierreihenfolge im Launcher.</summary>
+        public int Order { get; init; } = 0;
+
+        /// <summary>Erzeugt das anzuzeigende Control (frische Instanz je Fensteröffnung).</summary>
+        public Func<Control> CreateControl { get; init; } = () => new Control();
+
+        public int PreferredWidth { get; init; } = 900;
+        public int PreferredHeight { get; init; } = 600;
+    }
+
+    /// <summary>
+    /// Wird der Shell beim Start übergeben; Core und Module registrieren hier ihre Ansichten.
+    /// Der Launcher rendert daraus seine Einträge und öffnet je View ein Host-Fenster.
+    /// </summary>
+    public interface IModuleUiHost
+    {
+        void RegisterView(ModuleView view);
+    }
+}

src/PolyTrader.Core/PolyTrader.Core.csproj

@@ -4,6 +4,9 @@
     <TargetFramework>net8.0-windows</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <!-- Der Core stellt den UI-Contract (IModuleUiHost/ModuleView mit System.Windows.Forms.Control)
+         bereit, damit Module designbare UserControls beitragen können. -->
+    <UseWindowsForms>true</UseWindowsForms>
   </PropertyGroup>
 
   <ItemGroup>