implemented creation of TerminalViewModel Tabs with DI,

therefore added TerminalViewModelFactory,
revisited StartupHelpers (mainly added AbstractFactory)

Common/StartupHelpers/AbstractFactory.cs

@@ -7,16 +7,16 @@ public class AbstractFactory<T> : IAbstractFactory<T>
     /// <summary>
     /// Constructor for Abstract Factory.
     /// </summary>
-    /// <param name="factory">Function of the factory</param>
+    /// <param name="factory">factory function</param>
     public AbstractFactory(Func<T> factory)
     {
         this.factory = factory;
     }
 
     /// <summary>
-    /// Executes factory function and returns it.
+    /// Executes factory function and returns instanciated object.
     /// </summary>
-    /// <returns>Factory</returns>
+    /// <returns>created object</returns>
     public T Create()
     {
         return factory();

Common/StartupHelpers/ServiceExtensions.cs

@@ -4,6 +4,24 @@ namespace Common.StartupHelpers;
 
 public static class ServiceExtensions
 {
+    /// <summary>
+    /// Service Extension to add an <see cref="AbstractFactory{T}"/> to Dependency Injection.
+    /// </summary>
+    /// <typeparam name="TInterface">Type of interface</typeparam>
+    /// <typeparam name="TImplementation">Type of implementation</typeparam>
+    /// <param name="services">existing service collection</param>
+    public static void AddAbstractFactory<TInterface, TImplementation>(this IServiceCollection services)
+        where TInterface : class
+        where TImplementation : class, TInterface
+    {
+        // add implementation to services collection
+        services.AddTransient<TInterface, TImplementation>();
+        // add factory function to services collection
+        services.AddSingleton<Func<TInterface>>(x => () => x.GetService<TInterface>()!);
+        // add factory implementation to services collection
+        services.AddSingleton<IAbstractFactory<TInterface>, AbstractFactory<TInterface>>();
+    }
+
     /// <summary>
     /// Adds a factory for subcontrols to be created.
     /// For example a UserControl can be instanciated using this Service.
@@ -14,7 +32,7 @@ public static class ServiceExtensions
     {
         // add to DI: the subcontrol itself
         services.AddTransient<TSubControl>();
-        // add to DI: Func of that subcontrol, that will create the subcontrol
+        // add to DI: Func of constructor of that subcontrol
         services.AddSingleton<Func<TSubControl>>(x => () => x.GetService<TSubControl>()!);
         // add to DI: Factory for the subcontrol
         services.AddSingleton<IAbstractFactory<TSubControl>, AbstractFactory<TSubControl>>();

MultiTerm.Core/Factories/ITerminalViewModelFactory.cs

@@ -0,0 +1,10 @@
+using MultiTerm.Core.Common;
+using MultiTerm.Core.ViewModel;
+
+namespace MultiTerm.Core.Factories
+{
+    public interface ITerminalViewModelFactory
+    {
+        ITerminalViewModel Create(TerminalViewType viewType, ProtocolType protocolType);
+    }
+}

MultiTerm.Core/Factories/TerminalViewModelFactory.cs

@@ -0,0 +1,51 @@
+using MultiTerm.Core.Common;
+using MultiTerm.Core.ViewModel;
+
+namespace MultiTerm.Core.Factories;
+
+/// <summary>
+/// Can create <see cref="ITerminalViewModel"/> instances during runtime.
+/// </summary>
+public class TerminalViewModelFactory : ITerminalViewModelFactory
+{
+    private readonly Func<IEnumerable<ITerminalViewModel>> factory;
+
+    /// <summary>
+    /// Constructor of <see cref="TerminalViewModelFactory"/>.
+    /// </summary>
+    /// <param name="factory">function that gets all registered services with Interface <see cref="ITerminalViewModel"/></param>
+    public TerminalViewModelFactory(Func<IEnumerable<ITerminalViewModel>> factory)
+    {
+        this.factory = factory;
+    }
+
+    /// <summary>
+    /// Creates a new <see cref="ITerminalViewModel"/>.
+    /// </summary>
+    /// <param name="viewType"><see cref="TerminalViewType"/> of the new <see cref="ITerminalViewModel"/>. Must be set at creation time for all <see cref="ITerminalViewModel"/></param>
+    /// <param name="protocolType"><see cref="ProtocolType"/> of the new <see cref="ITerminalViewModel"/></param>
+    /// <returns></returns>
+    public ITerminalViewModel Create(TerminalViewType viewType, ProtocolType protocolType)
+    {
+        ITerminalViewModel output;
+
+        // get all registered TerminalViewModels as IEnumerable
+        var registeredViewModels = factory();
+
+        // search for correct type by ViewType which must be set in constructor of all TerminalViewModel Types
+        try
+        {
+            output = registeredViewModels.Where(x => x.ViewType == viewType).First();
+        }
+        catch (Exception ex)
+        {
+            throw new NotImplementedException($"'{nameof(TerminalViewModelFactory)}' cannot create Terminal with {nameof(TerminalViewType)} {viewType}", ex);
+        }
+
+        // immediately initialize protocol type
+        output.ProtocolType = protocolType;
+
+        // return the filled up instance
+        return output;
+    }
+}

MultiTerm.Core/Helpers/ServiceExtensions.cs

@@ -0,0 +1,27 @@
+using Microsoft.Extensions.DependencyInjection;
+using MultiTerm.Core.Factories;
+using MultiTerm.Core.ViewModel;
+
+namespace MultiTerm.Core.Helpers;
+
+public static class ServiceExtensions
+{
+    /// <summary>
+    /// Service Extension to add all implementations of <see cref="ITerminalViewModel"/> to Dependency Injection.
+    /// Also adds <see cref="TerminalViewModelFactory"/> to Dependency injection, which allows instanciation of <see cref="ITerminalViewModel"/> during runtime.
+    /// </summary>
+    /// <param name="services">existing services collection</param>
+    public static void AddTerminalViewModelFactory(this IServiceCollection services)
+    {
+        // add all implementations to the services collection
+        services.AddTransient<ITerminalViewModel, SendReceiveViewModel>();
+        // TODO extend
+
+        // add a function to the services collection, which is used by the TerminalViewModelFactory
+        // to get a list of all registered implementations of ITerminalViewModel
+        services.AddSingleton<Func<IEnumerable<ITerminalViewModel>>>(x => () => x.GetService<IEnumerable<ITerminalViewModel>>()!);
+
+        // add the factory itself to the services collection
+        services.AddSingleton<ITerminalViewModelFactory, TerminalViewModelFactory>();
+    }
+}

MultiTerm.Core/ViewModel/ITerminalViewModel.cs

@@ -17,7 +17,7 @@ public interface ITerminalViewModel
     /// <summary>
     /// Type of Protocol.
     /// </summary>
-    ProtocolType ProtocolType { get; }
+    ProtocolType ProtocolType { get; set; }
 
     /// <summary>
     /// Request Closing of Terminal.

MultiTerm.Core/ViewModel/SendReceiveViewModel.cs

@@ -4,12 +4,14 @@ namespace MultiTerm.Core.ViewModel;
 
 public partial class SendReceiveViewModel : TerminalViewModel
 {
-    public override string Title => "SendReceive Tab";
+    public override string Title 
-    public override TerminalViewType ViewType => TerminalViewType.SendReceive;
-
-    public SendReceiveViewModel() : base(ProtocolType.Serial) // TODO implement Protocol initialization
     {
-        
+        get
+        {
+            return $"{ViewType} {ProtocolType}";
+        }
     }
+    public override TerminalViewType ViewType => TerminalViewType.SendReceive;
+
 
 }

MultiTerm.Core/ViewModel/ShellViewModel.cs

@@ -2,14 +2,13 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using MultiTerm.Core.Common;
+using MultiTerm.Core.Factories;
 using System.Collections.ObjectModel;
 
 namespace MultiTerm.Core.ViewModel;
 
 public partial class ShellViewModel : ObservableObject
 {
-    private readonly IAbstractFactory<SendReceiveViewModel> sendReceiveViewModelFactory;
-
     [ObservableProperty]
     private string title = "ShellView Test";
 
@@ -35,17 +34,17 @@ public partial class ShellViewModel : ObservableObject
 
     #endregion
 
-    public ShellViewModel(IAbstractFactory<SendReceiveViewModel> sendReceiveViewModelFactory)
+    private readonly ITerminalViewModelFactory terminalViewModelFactory;
+
+    public ShellViewModel(ITerminalViewModelFactory terminalViewModelFactory)
     {
-        this.sendReceiveViewModelFactory = sendReceiveViewModelFactory;
+        this.terminalViewModelFactory = terminalViewModelFactory;
-        // create a new terminal
-        this.AppendConfiguredTerminal(this.sendReceiveViewModelFactory.Create());
     }
 
     [RelayCommand]
     private void AppendTerminalWithSelectedViewType(ProtocolType protocolType)
     {
-        Console.WriteLine($"Type = {protocolType}");
+        this.AppendConfiguredTerminal(this.terminalViewModelFactory.Create(this.SelectedTerminalViewType, protocolType));
     }
 
 
@@ -57,6 +56,7 @@ public partial class ShellViewModel : ObservableObject
         // add to collection and register closing event handler
         this.TerminalViewModels.Add(newTerminal);
         newTerminal.ClosingEvent += Terminal_ClosingEvent;
+
         // set as selected
         this.SelectedTerminalViewModel = newTerminal;
     }

MultiTerm.Core/ViewModel/TerminalViewModel.cs

@@ -8,15 +8,10 @@ public abstract partial class TerminalViewModel : ObservableObject, ITerminalVie
 {
     public abstract string Title { get; }
     public abstract TerminalViewType ViewType { get; }  
-    public ProtocolType ProtocolType { get; private set; }
+    public ProtocolType ProtocolType { get; set; }
 
     public event EventHandler? ClosingEvent;
 
-    public TerminalViewModel(ProtocolType protocolType)
-    {
-        this.ProtocolType = protocolType;
-    }
-
     /// <summary>
     /// Method to override if any closing actions are required.
     /// Closing can be cancelled using the return value.

MultiTerm.Wpf/App.xaml.cs

@@ -4,6 +4,7 @@ using MultiTerm.Core.ViewModel;
 using Common.StartupHelpers;
 using System.Windows;
 using MultiTerm.Core.Common;
+using MultiTerm.Core.Helpers;
 
 namespace MultiTerm.Wpf;
 
@@ -22,8 +23,8 @@ public partial class App : Application
                 // viewmodels
                 services.AddSingleton<ShellViewModel>();
 
-                // subcontrols
+                // application specific
-                services.AddSubControlFactory<SendReceiveViewModel>();
+                services.AddTerminalViewModelFactory();
             })
             .Build();
     }

MultiTerm.Wpf/View/ShellView.xaml

@@ -95,17 +95,6 @@
                             Command="{Binding Data.AppendTerminalWithSelectedViewTypeCommand, Source={StaticResource proxy}}"
                             CommandParameterType="{x:Type core_common:ProtocolType}">
                         </controls:CommandableSubMenu>
-                        
-                        <!--<MenuItem Header="Protocol" IsEnabled="False"/>
-                        
-                        <MenuItem Header="Serial"
-                            Command="{Binding Data.AppendTerminalCommand, Source={StaticResource proxy}}"
-                            CommandParameter="{Binding RelativeSource={RelativeSource Self}}">
-                        
-                        </MenuItem>
-                        <MenuItem Header="USB HID" />
-                        <MenuItem Header="TCP" />
-                        <MenuItem Header="UCP" />-->
                     </ContextMenu>
                 </Button.ContextMenu>