Method/property/field injection may not work when using Singleton/Scoped/PerResolve/PerBlock lifetime

NikolayPianikov · NikolayPianikov · commit 75048081edc1 · 2025-04-30T11:30:56.000+03:00
diff --git a/src/Pure.DI.Core/Core/Code/BuildTools.cs b/src/Pure.DI.Core/Core/Code/BuildTools.cs
@@ -63,7 +63,7 @@ public IEnumerable<Line> OnCreated(BuildContext ctx, Variable variable)
     {
         if (variable.Node.Arg is not null)
         {
-            return Array.Empty<Line>();
+            return [];
         }
 
         var baseTypes = new Lazy<ImmutableHashSet<ISymbol?>>(() =>
diff --git a/src/Pure.DI.Core/Core/Code/ImplementationCodeBuilder.cs b/src/Pure.DI.Core/Core/Code/ImplementationCodeBuilder.cs
@@ -38,7 +38,7 @@ public void Build(BuildContext ctx, in DpImplementation implementation)
             visits.Add((VisitFieldAction, field.Ordinal));
             continue;
 
-            void VisitFieldAction(BuildContext context) => injections.FieldInjection(variable.VariableName, context, field, fieldVariable);
+            void VisitFieldAction(BuildContext context) => injections.FieldInjection(context.Variable.VariableName, context, field, fieldVariable);
         }
 
         foreach (var property in implementation.Properties.Where(i => !i.Property.IsRequired && i.Property.SetMethod?.IsInitOnly != true))
@@ -48,7 +48,7 @@ public void Build(BuildContext ctx, in DpImplementation implementation)
             visits.Add((VisitFieldAction, property.Ordinal));
             continue;
 
-            void VisitFieldAction(BuildContext context) => injections.PropertyInjection(variable.VariableName, context, property, propertyVariable);
+            void VisitFieldAction(BuildContext context) => injections.PropertyInjection(context.Variable.VariableName, context, property, propertyVariable);
         }
 
         foreach (var method in implementation.Methods)
@@ -58,7 +58,7 @@ public void Build(BuildContext ctx, in DpImplementation implementation)
             visits.Add((VisitMethodAction, method.Ordinal));
             continue;
 
-            void VisitMethodAction(BuildContext context) => injections.MethodInjection(variable.VariableName, context, method, methodArgs);
+            void VisitMethodAction(BuildContext context) => injections.MethodInjection(context.Variable.VariableName, context, method, methodArgs);
         }
 
         var onCreatedStatements = ctx.BuildTools.OnCreated(ctx, ctx.Variable).ToList();
diff --git a/tests/Pure.DI.IntegrationTests/FieldInjectionTests.cs b/tests/Pure.DI.IntegrationTests/FieldInjectionTests.cs
@@ -2,8 +2,13 @@
 
 public class FieldInjectionTests
 {
-    [Fact]
-    public async Task ShouldSupportFieldInjection()
+    [Theory]
+    [InlineData(Lifetime.Transient)]
+    [InlineData(Lifetime.PerBlock)]
+    [InlineData(Lifetime.Singleton)]
+    [InlineData(Lifetime.Scoped)]
+    [InlineData(Lifetime.PerResolve)]
+    internal async Task ShouldSupportFieldInjection(Lifetime lifetime)
     {
         // Given
 
@@ -62,7 +67,7 @@ private static void SetupComposition()
                                    {
                                        DI.Setup("Composition")
                                            .Bind<IDependency>().To<Dependency>()
-                                           .Bind<IService>().To<Service>()
+                                           .Bind<IService>().As(Lifetime.#lifetime#).To<Service>()
                                            .Root<IService>("Service")
                                            .OrdinalAttribute<CustomOrdinalAttribute>();
                                    }
@@ -79,7 +84,7 @@ public static void Main()
                                    }
                                }
                            }
-                           """.RunAsync();
+                           """.Replace("#lifetime#", lifetime.ToString()).RunAsync();
 
         // Then
         result.Success.ShouldBeTrue(result);
diff --git a/tests/Pure.DI.IntegrationTests/MethodInjectionTests.cs b/tests/Pure.DI.IntegrationTests/MethodInjectionTests.cs
@@ -2,8 +2,13 @@
 
 public class MethodInjectionTests
 {
-    [Fact]
-    public async Task ShouldSupportMethodInjection()
+    [Theory]
+    [InlineData(Lifetime.Transient, "Initialize dep", "Initialize dep", "Initialize", "False", "Activate")]
+    [InlineData(Lifetime.PerBlock, "Initialize dep", "Initialize", "True", "Activate")]
+    [InlineData(Lifetime.Singleton, "Initialize dep", "Initialize", "True", "Activate")]
+    [InlineData(Lifetime.Scoped, "Initialize dep", "Initialize", "True", "Activate")]
+    [InlineData(Lifetime.PerResolve, "Initialize dep", "Initialize", "True", "Activate")]
+    internal async Task ShouldSupportMethodInjection(Lifetime lifetime, params string[] output)
     {
         // Given
 
@@ -55,7 +60,7 @@ public void Activate()
                                    internal void Initialize(IDependency dep)
                                    {
                                        Console.WriteLine("Initialize");
-                                       Console.WriteLine(dep != Dep);
+                                       Console.WriteLine(dep == Dep);
                                    }
                                }
                            
@@ -64,7 +69,7 @@ static class Setup
                                    private static void SetupComposition()
                                    {
                                        DI.Setup("Composition")
-                                           .Bind<IDependency>().To<Dependency>()
+                                           .Bind<IDependency>().As(Lifetime.#lifetime#).To<Dependency>()
                                            .Bind<IService>().To<Service>()
                                            .Arg<string>("depName", 374)
                                            .Root<IService>("Service");
@@ -80,11 +85,11 @@ public static void Main()
                                    }
                                }
                            }
-                           """.RunAsync();
+                           """.Replace("#lifetime#", lifetime.ToString()).RunAsync();
 
         // Then
         result.Success.ShouldBeTrue(result);
-        result.StdOut.ShouldBe(["Initialize dep", "Initialize dep", "Initialize", "True", "Activate"], result);
+        result.StdOut.ShouldBe([..output], result);
     }
 
     [Fact]
diff --git a/tests/Pure.DI.IntegrationTests/PropertyInjectionTests.cs b/tests/Pure.DI.IntegrationTests/PropertyInjectionTests.cs
@@ -2,9 +2,13 @@
 
 public class PropertyInjectionTests
 {
-
-    [Fact]
-    public async Task ShouldSupportInitPropertyInjection()
+    [Theory]
+    [InlineData(Lifetime.Transient)]
+    [InlineData(Lifetime.PerBlock)]
+    [InlineData(Lifetime.Singleton)]
+    [InlineData(Lifetime.Scoped)]
+    [InlineData(Lifetime.PerResolve)]
+    internal async Task ShouldSupportInitPropertyInjection(Lifetime lifetime)
     {
         // Given
 
@@ -74,7 +78,7 @@ private static void SetupComposition()
                                    {
                                        DI.Setup("Composition")
                                            .Bind<IDependency>().To<Dependency>()
-                                           .Bind<IService>().To<Service>()
+                                           .Bind<IService>().As(Lifetime.#lifetime#).To<Service>()
                                            .Root<IService>("Service")
                                            .OrdinalAttribute<CustomOrdinalAttribute>();
                                    }
@@ -89,14 +93,20 @@ public static void Main()
                                    }
                                }
                            }
-                           """.RunAsync(new Options(LanguageVersion.CSharp9));
+                           """.Replace("#lifetime#", lifetime.ToString()).RunAsync(new Options(LanguageVersion.CSharp9));
 
         // Then
         result.Success.ShouldBeTrue(result);
         result.StdOut.ShouldBe(["OtherDep1", "True", "OtherDep0", "True"], result);
     }
-    [Fact]
-    public async Task ShouldSupportPropertyInjection()
+
+    [Theory]
+    [InlineData(Lifetime.Transient)]
+    [InlineData(Lifetime.PerBlock)]
+    [InlineData(Lifetime.Singleton)]
+    [InlineData(Lifetime.Scoped)]
+    [InlineData(Lifetime.PerResolve)]
+    internal async Task ShouldSupportPropertyInjection(Lifetime lifetime)
     {
         // Given
 
@@ -166,7 +176,7 @@ private static void SetupComposition()
                                    {
                                        DI.Setup("Composition")
                                            .Bind<IDependency>().To<Dependency>()
-                                           .Bind<IService>().To<Service>()
+                                           .Bind<IService>().As(Lifetime.#lifetime#).To<Service>()
                                            .Root<IService>("Service")
                                            .OrdinalAttribute<CustomOrdinalAttribute>();
                                    }
@@ -181,7 +191,7 @@ public static void Main()
                                    }
                                }
                            }
-                           """.RunAsync();
+                           """.Replace("#lifetime#", lifetime.ToString()).RunAsync();
 
         // Then
         result.Success.ShouldBeTrue(result);

Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ public IEnumerable<Line> OnCreated(BuildContext ctx, Variable variable)`
`63`	`63`	`{`
`64`	`64`	`if (variable.Node.Arg is not null)`
`65`	`65`	`{`
`66`		`- return Array.Empty<Line>();`
	`66`	`+ return [];`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`var baseTypes = new Lazy<ImmutableHashSet<ISymbol?>>(() =>`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public void Build(BuildContext ctx, in DpImplementation implementation)`
`38`	`38`	`visits.Add((VisitFieldAction, field.Ordinal));`
`39`	`39`	`continue;`
`40`	`40`
`41`		`- void VisitFieldAction(BuildContext context) => injections.FieldInjection(variable.VariableName, context, field, fieldVariable);`
	`41`	`+ void VisitFieldAction(BuildContext context) => injections.FieldInjection(context.Variable.VariableName, context, field, fieldVariable);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`foreach (var property in implementation.Properties.Where(i => !i.Property.IsRequired && i.Property.SetMethod?.IsInitOnly != true))`
`@@ -48,7 +48,7 @@ public void Build(BuildContext ctx, in DpImplementation implementation)`
`48`	`48`	`visits.Add((VisitFieldAction, property.Ordinal));`
`49`	`49`	`continue;`
`50`	`50`
`51`		`- void VisitFieldAction(BuildContext context) => injections.PropertyInjection(variable.VariableName, context, property, propertyVariable);`
	`51`	`+ void VisitFieldAction(BuildContext context) => injections.PropertyInjection(context.Variable.VariableName, context, property, propertyVariable);`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`foreach (var method in implementation.Methods)`
`@@ -58,7 +58,7 @@ public void Build(BuildContext ctx, in DpImplementation implementation)`
`58`	`58`	`visits.Add((VisitMethodAction, method.Ordinal));`
`59`	`59`	`continue;`
`60`	`60`
`61`		`- void VisitMethodAction(BuildContext context) => injections.MethodInjection(variable.VariableName, context, method, methodArgs);`
	`61`	`+ void VisitMethodAction(BuildContext context) => injections.MethodInjection(context.Variable.VariableName, context, method, methodArgs);`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`var onCreatedStatements = ctx.BuildTools.OnCreated(ctx, ctx.Variable).ToList();`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,13 @@`
`2`	`2`
`3`	`3`	`public class FieldInjectionTests`
`4`	`4`	`{`
`5`		`- [Fact]`
`6`		`- public async Task ShouldSupportFieldInjection()`
	`5`	`+ [Theory]`
	`6`	`+ [InlineData(Lifetime.Transient)]`
	`7`	`+ [InlineData(Lifetime.PerBlock)]`
	`8`	`+ [InlineData(Lifetime.Singleton)]`
	`9`	`+ [InlineData(Lifetime.Scoped)]`
	`10`	`+ [InlineData(Lifetime.PerResolve)]`
	`11`	`+ internal async Task ShouldSupportFieldInjection(Lifetime lifetime)`
`7`	`12`	`{`
`8`	`13`	`// Given`
`9`	`14`
`@@ -62,7 +67,7 @@ private static void SetupComposition()`
`62`	`67`	`{`
`63`	`68`	`DI.Setup("Composition")`
`64`	`69`	`.Bind<IDependency>().To<Dependency>()`
`65`		`- .Bind<IService>().To<Service>()`
	`70`	`+ .Bind<IService>().As(Lifetime.#lifetime#).To<Service>()`
`66`	`71`	`.Root<IService>("Service")`
`67`	`72`	`.OrdinalAttribute<CustomOrdinalAttribute>();`
`68`	`73`	`}`
`@@ -79,7 +84,7 @@ public static void Main()`
`79`	`84`	`}`
`80`	`85`	`}`
`81`	`86`	`}`
`82`		`- """.RunAsync();`
	`87`	`+ """.Replace("#lifetime#", lifetime.ToString()).RunAsync();`
`83`	`88`
`84`	`89`	`// Then`
`85`	`90`	`result.Success.ShouldBeTrue(result);`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,13 @@`
`2`	`2`
`3`	`3`	`public class MethodInjectionTests`
`4`	`4`	`{`
`5`		`- [Fact]`
`6`		`- public async Task ShouldSupportMethodInjection()`
	`5`	`+ [Theory]`
	`6`	`+ [InlineData(Lifetime.Transient, "Initialize dep", "Initialize dep", "Initialize", "False", "Activate")]`
	`7`	`+ [InlineData(Lifetime.PerBlock, "Initialize dep", "Initialize", "True", "Activate")]`
	`8`	`+ [InlineData(Lifetime.Singleton, "Initialize dep", "Initialize", "True", "Activate")]`
	`9`	`+ [InlineData(Lifetime.Scoped, "Initialize dep", "Initialize", "True", "Activate")]`
	`10`	`+ [InlineData(Lifetime.PerResolve, "Initialize dep", "Initialize", "True", "Activate")]`
	`11`	`+ internal async Task ShouldSupportMethodInjection(Lifetime lifetime, params string[] output)`
`7`	`12`	`{`
`8`	`13`	`// Given`
`9`	`14`
`@@ -55,7 +60,7 @@ public void Activate()`
`55`	`60`	`internal void Initialize(IDependency dep)`
`56`	`61`	`{`
`57`	`62`	`Console.WriteLine("Initialize");`
`58`		`- Console.WriteLine(dep != Dep);`
	`63`	`+ Console.WriteLine(dep == Dep);`
`59`	`64`	`}`
`60`	`65`	`}`
`61`	`66`
`@@ -64,7 +69,7 @@ static class Setup`
`64`	`69`	`private static void SetupComposition()`
`65`	`70`	`{`
`66`	`71`	`DI.Setup("Composition")`
`67`		`- .Bind<IDependency>().To<Dependency>()`
	`72`	`+ .Bind<IDependency>().As(Lifetime.#lifetime#).To<Dependency>()`
`68`	`73`	`.Bind<IService>().To<Service>()`
`69`	`74`	`.Arg<string>("depName", 374)`
`70`	`75`	`.Root<IService>("Service");`
`@@ -80,11 +85,11 @@ public static void Main()`
`80`	`85`	`}`
`81`	`86`	`}`
`82`	`87`	`}`
`83`		`- """.RunAsync();`
	`88`	`+ """.Replace("#lifetime#", lifetime.ToString()).RunAsync();`
`84`	`89`
`85`	`90`	`// Then`
`86`	`91`	`result.Success.ShouldBeTrue(result);`
`87`		`- result.StdOut.ShouldBe(["Initialize dep", "Initialize dep", "Initialize", "True", "Activate"], result);`
	`92`	`+ result.StdOut.ShouldBe([..output], result);`
`88`	`93`	`}`
`89`	`94`
`90`	`95`	`[Fact]`
Original file line number	Diff line number	Diff line change
`@@ -2,9 +2,13 @@`
`2`	`2`
`3`	`3`	`public class PropertyInjectionTests`
`4`	`4`	`{`
`5`		`-`
`6`		`- [Fact]`
`7`		`- public async Task ShouldSupportInitPropertyInjection()`
	`5`	`+ [Theory]`
	`6`	`+ [InlineData(Lifetime.Transient)]`
	`7`	`+ [InlineData(Lifetime.PerBlock)]`
	`8`	`+ [InlineData(Lifetime.Singleton)]`
	`9`	`+ [InlineData(Lifetime.Scoped)]`
	`10`	`+ [InlineData(Lifetime.PerResolve)]`
	`11`	`+ internal async Task ShouldSupportInitPropertyInjection(Lifetime lifetime)`
`8`	`12`	`{`
`9`	`13`	`// Given`
`10`	`14`
`@@ -74,7 +78,7 @@ private static void SetupComposition()`
`74`	`78`	`{`
`75`	`79`	`DI.Setup("Composition")`
`76`	`80`	`.Bind<IDependency>().To<Dependency>()`
`77`		`- .Bind<IService>().To<Service>()`
	`81`	`+ .Bind<IService>().As(Lifetime.#lifetime#).To<Service>()`
`78`	`82`	`.Root<IService>("Service")`
`79`	`83`	`.OrdinalAttribute<CustomOrdinalAttribute>();`
`80`	`84`	`}`
`@@ -89,14 +93,20 @@ public static void Main()`
`89`	`93`	`}`
`90`	`94`	`}`
`91`	`95`	`}`
`92`		`- """.RunAsync(new Options(LanguageVersion.CSharp9));`
	`96`	`+ """.Replace("#lifetime#", lifetime.ToString()).RunAsync(new Options(LanguageVersion.CSharp9));`
`93`	`97`
`94`	`98`	`// Then`
`95`	`99`	`result.Success.ShouldBeTrue(result);`
`96`	`100`	`result.StdOut.ShouldBe(["OtherDep1", "True", "OtherDep0", "True"], result);`
`97`	`101`	`}`
`98`		`- [Fact]`
`99`		`- public async Task ShouldSupportPropertyInjection()`
	`102`	`+`
	`103`	`+ [Theory]`
	`104`	`+ [InlineData(Lifetime.Transient)]`
	`105`	`+ [InlineData(Lifetime.PerBlock)]`
	`106`	`+ [InlineData(Lifetime.Singleton)]`
	`107`	`+ [InlineData(Lifetime.Scoped)]`
	`108`	`+ [InlineData(Lifetime.PerResolve)]`
	`109`	`+ internal async Task ShouldSupportPropertyInjection(Lifetime lifetime)`
`100`	`110`	`{`
`101`	`111`	`// Given`
`102`	`112`
`@@ -166,7 +176,7 @@ private static void SetupComposition()`
`166`	`176`	`{`
`167`	`177`	`DI.Setup("Composition")`
`168`	`178`	`.Bind<IDependency>().To<Dependency>()`
`169`		`- .Bind<IService>().To<Service>()`
	`179`	`+ .Bind<IService>().As(Lifetime.#lifetime#).To<Service>()`
`170`	`180`	`.Root<IService>("Service")`
`171`	`181`	`.OrdinalAttribute<CustomOrdinalAttribute>();`
`172`	`182`	`}`
`@@ -181,7 +191,7 @@ public static void Main()`
`181`	`191`	`}`
`182`	`192`	`}`
`183`	`193`	`}`
`184`		`- """.RunAsync();`
	`194`	`+ """.Replace("#lifetime#", lifetime.ToString()).RunAsync();`
`185`	`195`
`186`	`196`	`// Then`
`187`	`197`	`result.Success.ShouldBeTrue(result);`