- upload expression test

LightweightIocContainer/Expressions.cs

@@ -0,0 +1,31 @@
+// Author: Simon.Gockner
+// Created: 2024-04-17
+// Copyright(c) 2024 SimonG. All Rights Reserved.
+
+using System.Linq.Expressions;
+using System.Reflection;
+using FastExpressionCompiler;
+
+namespace LightweightIocContainer;
+
+internal class Expressions
+{
+    public T Create<T>(ConstructorInfo constructor, params object?[]? arguments)
+    {
+        (Expression? expression, IEnumerable<ParameterExpression> parameters) = CreateConstructorExpression(constructor);
+        return ((Func<T>) Expression.Lambda(expression, parameters).CompileFast())(); //TODO: Pass arguments to func? (don't use dynamicInvoke if possible), maybe use factory class?
+    }
+
+    private (Expression expression, IEnumerable<ParameterExpression> parameters) CreateConstructorExpression(ConstructorInfo constructor)
+    {
+        ParameterInfo[] parameters = constructor.GetParameters();
+        if (parameters.Length == 0)
+            return (Expression.New(constructor), []);
+
+        ParameterExpression[] parameterExpressions = new ParameterExpression[parameters.Length];
+        for (int i = 0; i < parameters.Length; i++) 
+            parameterExpressions[i] = Expression.Parameter(parameters[i].ParameterType);
+
+        return (Expression.New(constructor, parameterExpressions.Cast<Expression>()), parameterExpressions);
+    }
+}

LightweightIocContainer/Factories/TypedFactory.cs

@@ -4,6 +4,7 @@
 
 using System.Reflection;
 using System.Reflection.Emit;
+using GProxy;
 using LightweightIocContainer.Exceptions;
 using LightweightIocContainer.Interfaces;
 using LightweightIocContainer.Interfaces.Factories;
@@ -22,7 +23,11 @@ public class TypedFactory<TFactory> : TypedFactoryBase<TFactory>, ITypedFactory<
     /// The 
     /// </summary>
     /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-    public TypedFactory(IocContainer container) => Factory = CreateFactory(container);
+    public TypedFactory(IocContainer container)
+    {
+        //Factory = CreateFactory(container);
+        Factory = Proxy.Of<TFactory>();
+    }
 
     /// <summary>
     /// The implemented abstract typed factory/>

LightweightIocContainer/LightweightIocContainer.csproj

@@ -23,6 +23,9 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FastExpressionCompiler" Version="4.1.0" />
+    <PackageReference Include="GProxy" Version="0.0.1-alpha" />
+    <PackageReference Include="GProxy.Generators" Version="0.0.1-alpha" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

Test.LightweightIocContainer/ExpressionsTest.cs

@@ -0,0 +1,37 @@
+// Author: Simon.Gockner
+// Created: 2024-04-24
+// Copyright(c) 2024 SimonG. All Rights Reserved.
+
+using System.Reflection;
+using LightweightIocContainer;
+using NUnit.Framework;
+
+namespace Test.LightweightIocContainer;
+
+public class ExpressionsTest
+{
+    public class TestNoCtor;
+    public class TestWithCtor(string name);
+    
+    [Test]
+    public void TestCreateExpressionWithDefaultCtor()
+    {
+        Expressions expressions = new();
+
+        ConstructorInfo defaultCtor = typeof(TestNoCtor).GetConstructors().First();
+        TestNoCtor testNoCtor = expressions.Create<TestNoCtor>(defaultCtor);
+        
+        Assert.That(testNoCtor, Is.InstanceOf<TestNoCtor>());
+    }
+    
+    [Test]
+    public void TestCreateExpressionWithParamCtor()
+    {
+        Expressions expressions = new();
+
+        ConstructorInfo paramCtor = typeof(TestWithCtor).GetConstructors().First();
+        TestWithCtor testWithCtor = expressions.Create<TestWithCtor>(paramCtor, "TestName");
+        
+        Assert.That(testWithCtor, Is.InstanceOf<TestWithCtor>());
+    }
+}