StackOverflow happens while resolving with DependencyOverride + OptionalParameter

[abramovandrey]

Description

Resolution with DependencyOverride + OptionalParameter ends with StackOverflow Exception since 5.9.0. All versions before 5.9.0 (including 5.8.13) Resolves TestClass in example below without issues.

To Reproduce

        [TestMethod]
        public void OptionalParameterTest()
        {
            using (var container = new UnityContainer())
            {
		// BUG: StackOverflow happens here since 5.9.0
                var instance = container.Resolve<TestClass>(new DependencyOverride<string>(new OptionalParameter<string>()));
                Assert.IsNull(instance.Field);

                container.RegisterInstance("123");
                instance = container.Resolve<TestClass>(new DependencyOverride<string>(new OptionalParameter<string>()));
                Assert.AreEqual("123", instance.Field);
            }
        }

        public class TestClass
        {
            public TestClass(string field)
            {
                this.Field = field;
            }		
            public string Field { get; }
        }

[ENikS]

Yes, what you have here is cyclical dependency. For more info see Dependency Override

When you are trying to resolve OptionalParameter<string>() the request never reaches the container. DependencyOverride<string>(...) overrides it, and again, hands it over to OptionalParameter<string>() to resolve. OptionalParameter<string>(), again, tries to resolve it from the container but is overridden and going back to DependencyOverride<string>(...), and etc.

With enabled Diagnostics it should throw. ... but it does not.

[ENikS]

This is the correct way of overriding a parameter to take an optional value:

var instance = Container.Resolve<TestClass>(
    Override.Parameter<string>(
        Resolve.Optional<string>()));

Assert.IsNull(instance.Field);

Container.RegisterInstance("123");

instance = Container.Resolve<TestClass>(
    Override.Parameter<string>(
        Resolve.Optional<string>()));

Assert.AreEqual("123", instance.Field);

[abramovandrey]

Proposed solution does not work for me unfortunately, as actual usage of DependencyOverride is folowing:
` [Test]
public void ContainerTest()
{
using (var container = new UnityContainer())
{
var instance = container.Resolve(new DependencyOverride(new OptionalParameter()));
Assert.IsNull(instance.Nested.Field);

            container.RegisterInstance("123");
            instance = container.Resolve<TestClass>(new DependencyOverride<string>(new OptionalParameter<string>()));
            Assert.AreEqual("123", instance.Nested.Field);
        }
    }
    
    public class TestClass
    {
        public TestClass(TestNestedClass nested)
        {
            this.Nested = nested;
        }

        public TestNestedClass Nested { get; }
    }

    public class TestNestedClass
    {
        public TestNestedClass(string field)
        {
            this.Field = field;
        }

        public string Field { get; }
    }

`
and actual nesting level in project is much deeper than in this example.

You said, that "what you have here is cyclical dependency". That is not true. I do not have circular dependency in classes. Container somehow got circle in dependency override michanism in 5.9.0 and 5.10.1 still has StackOverflow Exception in example above.

[ENikS]

Andrey, I understand your frustration, but unfortunately, it is technical limitation, rather than my decision. I’ve tried to make it work the way you wanted it (see #140) but I was unable to. From now on, this is the behavior Unity will be implementing.