#84 Error “Sequence does not contain elements” when using BuildUp wit…

…h non-transitive dependencies
DevTeam · Jan 16, 2025 · 969fee5 · 969fee5
1 parent 06d7e4e
commit 969fee5
Show file tree

Hide file tree

Showing 2 changed files with 75 additions and 1 deletion.
diff --git a/src/Pure.DI.Core/Core/Code/FactoryCodeBuilder.cs b/src/Pure.DI.Core/Core/Code/FactoryCodeBuilder.cs
@@ -220,7 +220,7 @@ public void Build(BuildContext ctx, in DpFactory factory)
             .Zip(factory.Initializers, (initialization, initializer) => (initialization, initializer))
             .GetEnumerator();
 
-        var  initializationArgsEnum = initializationArgs.OfType<Variable>().GetEnumerator();
+        var initializationArgsEnum = initializationArgs.Select(i => i.Current).GetEnumerator();
 
         var injectionsCtx = ctx;
         if (variable.IsLazy && variable.Node.Accumulators.Count > 0)

diff --git a/tests/Pure.DI.IntegrationTests/FactoryTests.cs b/tests/Pure.DI.IntegrationTests/FactoryTests.cs
@@ -2078,4 +2078,78 @@ public static void Main()
         result.Success.ShouldBeTrue(result);
         result.StdOut.ShouldBe(["Initialize Abc"], result);
     }
+
+    [Theory]
+    [InlineData(Lifetime.Transient)]
+    [InlineData(Lifetime.PerBlock)]
+    [InlineData(Lifetime.PerResolve)]
+    [InlineData(Lifetime.Scoped)]
+    [InlineData(Lifetime.Singleton)]
+    internal async Task ShouldSupportBuildUpWhenLifetime(Lifetime lifetime)
+    {
+        // Given
+
+        // When
+        var result = await """
+                           using System;
+                           using Pure.DI;
+
+                           namespace Sample
+                           {
+                               class ClientScript
+                               {
+                                   [Ordinal(1)] public IService1? service1;
+                                   
+                                   [Ordinal(2)] public IService2? service2;
+                               }
+                               
+                               interface IService1
+                               {
+                               };
+                               
+                               internal class Service1 : IService1
+                               {
+                               };
+                               
+                               interface IService2
+                               {
+                               };
+                               
+                               internal class Service2 : IService2
+                               {
+                               };
+                           
+                               static class Setup
+                               {
+                                   private static void SetupComposition()
+                                   {
+                                       DI.Setup("Composition")
+                                           .Bind().To<Service1>()
+                                           .Bind().As(Lifetime.#lifetime#).To<Service2>()
+                                           .Bind().To<ClientScript>(ctx =>
+                                           {
+                                               ctx.Inject("from arg", out ClientScript script);
+                                               ctx.BuildUp(script);
+                                               return script;
+                                           })
+                                           .RootArg<ClientScript>("clientScript", "from arg")
+                                           .Root<ClientScript>("Initialize");
+                                   }
+                               }
+                           
+                               public class Program
+                               {
+                                   public static void Main()
+                                   {
+                                       var composition = new Composition();
+                                       var script = new ClientScript();
+                                       script = composition.Initialize(script);
+                                   }
+                               }
+                           }
+                           """.Replace("#lifetime#", lifetime.ToString()).RunAsync();
+
+        // Then
+        result.Errors.Count.ShouldBe(0, result);
+    }
 }