Test statements

TestStatements/AppWithPlugin/AppWithPlugin.csproj

@@ -0,0 +1,21 @@
+<Project>
+	<ImportGroup Label="SolutionProps">
+		<Import Project="..\Solution_net.props" />
+	</ImportGroup>
+	<PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+	<Import Sdk="Microsoft.NET.Sdk" Project="Sdk.props" />
+	<Import Sdk="Microsoft.NET.Sdk" Project="Sdk.targets" />
+	<ItemGroup>
+	  <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.0" />
+	  <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.0" />
+	  <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.0" />
+	</ItemGroup>
+	<ItemGroup>
+	  <ProjectReference Include="..\PluginBase\PluginBase.csproj" />
+	</ItemGroup>
+
+</Project>

TestStatements/AppWithPlugin/Model/AppWithPlugin.cs

@@ -0,0 +1,149 @@
+using CommunityToolkit.Mvvm.Messaging;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using PluginBase.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AppWithPlugin.Model;
+
+public class AppWithPlugin : IEnvironment, IUserInterface
+{
+    static Assembly LoadPlugin(string relativePath)
+    {
+        // Navigate up to the solution root
+        string root = Path.GetFullPath(Path.Combine(
+                Path.GetDirectoryName(
+                    Path.GetDirectoryName(
+                        Path.GetDirectoryName(
+                            Path.GetDirectoryName(typeof(Program).Assembly.Location))))));
+
+        string pluginLocation = Path.GetFullPath(Path.Combine(root, relativePath.Replace('\\', Path.DirectorySeparatorChar),"Debug", "net6.0"));
+        Console.WriteLine($"Loading commands from: {pluginLocation}");
+        PluginLoadContext loadContext = new PluginLoadContext(pluginLocation);
+        return loadContext.LoadFromAssemblyPath(Path.Combine(pluginLocation,relativePath)+".dll");
+    }
+
+    static IEnumerable<ICommand> CreateCommands(Assembly assembly,IEnvironment env)
+    {
+        int count = 0;
+
+        foreach (Type type in assembly.GetTypes())
+        {
+            if (typeof(ICommand).IsAssignableFrom(type))
+            {
+                ICommand result = Activator.CreateInstance(type) as ICommand;
+                if (result != null)
+                {
+                    result.Initialize(env);
+                    count++;
+                    yield return result;
+                }
+            }
+        }
+
+        if (count == 0)
+        {
+            string availableTypes = string.Join(",", assembly.GetTypes().Select(t => t.FullName));
+            throw new ApplicationException(
+                $"Can't find any type which implements ICommand in {assembly} from {assembly.Location}.\n" +
+                $"Available types: {availableTypes}");
+        }
+    }
+
+    IEnumerable<ICommand>? commands;
+    private IMessenger? _messanger;
+    private IServiceProvider? _sp;
+
+    public IData data { get => throw new NotImplementedException(); }
+    public IUserInterface ui { get => this; }
+    public IMessenger messaging { get => _messanger ?? new WeakReferenceMessenger(); }
+    public string Title { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+    public void Initialize(string[] args)
+    {
+        _sp = new ServiceCollection()
+            .AddTransient<IRandom, Model.Random>()
+            .AddTransient<ISysTime, Model.SysTime>()
+            .AddSingleton<ILogger, Logging>()
+            .BuildServiceProvider();
+
+
+        string[] pluginPaths =
+            [
+                "HelloPlugin"
+            ];
+
+        commands = pluginPaths.SelectMany(pluginPath =>
+    {
+        Assembly pluginAssembly = LoadPlugin(pluginPath);
+        return CreateCommands(pluginAssembly,this);
+    }).ToList();
+        Console.WriteLine("AppWithPlugin is initialized.");
+    }
+
+    public void Main(string[] args)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] == "/d")
+            {
+                Console.WriteLine("Waiting for any key...");
+                Console.ReadLine();
+            }
+
+
+            if (args.Length == 0)
+            {
+                Console.WriteLine("Commands: ");
+                foreach (ICommand command in commands)
+                {
+                    Console.WriteLine($"{command.Name}\t - {command.Description}");
+                }
+            }
+            else
+            {
+                foreach (string commandName in args)
+                {
+                    Console.WriteLine($"-- {commandName} --");
+
+                    ICommand command = commands.FirstOrDefault(c => c.Name.ToUpper() == commandName.ToUpper());
+                    if (command == null)
+                    {
+                        Console.WriteLine("No such command is known.");
+                        return;
+                    }
+
+                    command.Execute();
+
+                    Console.WriteLine();
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex);
+        }
+    }
+
+    public T? GetService<T>()
+    {
+        return _sp.GetService<T>();
+    }
+
+    public bool AddService<T>(T service)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool ShowMessage(string message)
+    {
+        Console.WriteLine(message);
+        return true;
+    }
+}

TestStatements/AppWithPlugin/Model/Logging.cs

@@ -0,0 +1,24 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Diagnostics;
+
+namespace AppWithPlugin.Model
+{
+    public class Logging : ILogger
+    {
+        public IDisposable? BeginScope<TState>(TState state) where TState : notnull
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsEnabled(LogLevel logLevel)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        {
+            Debug.WriteLine($"[{logLevel}] {eventId.Id} {formatter(state, exception)}");
+        }
+    }
+}

TestStatements/AppWithPlugin/Model/PluginLoadContext.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Reflection;
+using System.Runtime.Loader;
+
+namespace AppWithPlugin.Model;
+
+class PluginLoadContext : AssemblyLoadContext
+{
+    private AssemblyDependencyResolver _resolver;
+
+    public PluginLoadContext(string pluginPath)
+    {
+        _resolver = new AssemblyDependencyResolver(pluginPath);
+    }
+
+    protected override Assembly? Load(AssemblyName assemblyName)
+    {
+        string? assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);
+        if (assemblyPath != null)
+        {
+            return LoadFromAssemblyPath(assemblyPath);
+        }
+
+        return null;
+    }
+
+    protected override nint LoadUnmanagedDll(string unmanagedDllName)
+    {
+        string? libraryPath = _resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
+        if (libraryPath != null)
+        {
+            return LoadUnmanagedDllFromPath(libraryPath);
+        }
+
+#if NET7_0_OR_GREATER
+        return nint.Zero;
+#else
+        return IntPtr.Zero;
+#endif
+    }
+}

TestStatements/AppWithPlugin/Model/Random.cs

@@ -0,0 +1,47 @@
+using PluginBase.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AppWithPlugin.Model;
+
+public class Random : IRandom
+{
+    private System.Random _random;
+
+    public Random()
+    {
+        _random = new System.Random();
+    }
+    public int Next()
+    {
+        return _random.Next();
+    }
+
+    public int Next(int maxValue)
+    {
+        return _random.Next(maxValue);
+    }
+
+    public int Next(int minValue, int maxValue)
+    {
+        return _random.Next(minValue, maxValue);
+    }
+
+    public void NextBytes(byte[] buffer)
+    {
+        _random.NextBytes(buffer);
+    }
+
+    public double NextDouble()
+    {
+        return _random.NextDouble();
+    }
+
+    public void Seed(int seed)
+    {
+        _random = new System.Random(seed);
+    }
+}

TestStatements/AppWithPlugin/Model/SysTime.cs

@@ -0,0 +1,14 @@
+using PluginBase.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AppWithPlugin.Model
+{
+    public class SysTime : ISysTime
+    {
+        public DateTime Now => DateTime.Now;
+    }
+}

TestStatements/AppWithPlugin/Program.cs

@@ -0,0 +1,18 @@
+using PluginBase;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+namespace AppWithPlugin;
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        var app = new Model.AppWithPlugin();
+        app.Initialize(args);
+        app.Main(args);
+    }
+}

TestStatements/AppWithPlugin/Properties/launchSettings.json

@@ -0,0 +1,23 @@
+{
+  "profiles": {
+    "AppWithPlugin": {
+      "commandName": "Project"
+    },
+    "WSL": {
+      "commandName": "WSL2",
+      "distributionName": ""
+    },
+    "AppWithPlugin /d": {
+      "commandName": "Project",
+      "commandLineArgs": "/d"
+    },
+    "AppWithPlugin Hello": {
+      "commandName": "Project",
+      "commandLineArgs": "Hello"
+    },
+    "Profil \"1\"": {
+      "commandName": "Project",
+      "commandLineArgs": "Test"
+    }
+  }
+}

TestStatements/AsyncExampleWPF/App.xaml.cs

@@ -1,10 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Configuration;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
-using System.Windows;
+using System.Windows;
 
 namespace AsyncExampleWPF
 {

TestStatements/AsyncExampleWPF/AsyncExampleWPF.csproj

@@ -4,7 +4,7 @@
   </ImportGroup>
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
-    <TargetFrameworks>net462-windows;net472-windows;net48-windows;net481-windows</TargetFrameworks>
+    <TargetFrameworks>net462-windows;net472-windows;net481-windows</TargetFrameworks>
     <UseWPF>true</UseWPF>
   </PropertyGroup>
 

TestStatements/AsyncExampleWPF/AsyncExampleWPF_net.csproj

@@ -6,7 +6,6 @@
     <OutputType>WinExe</OutputType>
     <TargetFrameworks>net6.0-windows;net7.0-windows;net8.0-windows</TargetFrameworks>
     <UseWPF>true</UseWPF>
-    <LangVersion>12.0</LangVersion>
   </PropertyGroup>
   <Import Sdk="Microsoft.NET.Sdk" Project="Sdk.props" />
   <Import Sdk="Microsoft.NET.Sdk" Project="Sdk.targets" />

TestStatements/AsyncExampleWPF/MainWindow.xaml.cs

@@ -8,10 +8,7 @@
 using System.Net;
 using System.IO;
 using System.Linq;
-using System.Threading;
 using System.Diagnostics;
-using System.Security.Policy;
-using System.Collections;
 
 namespace AsyncExampleWPF
 {

TestStatements/CallAllExamples/CallAllExamples_net.csproj

@@ -5,7 +5,6 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
-    <LangVersion>12.0</LangVersion>
   </PropertyGroup>
   <Import Sdk="Microsoft.NET.Sdk" Project="Sdk.props" />
   <Import Sdk="Microsoft.NET.Sdk" Project="Sdk.targets" />