C# WindsorContainer TypedFactory如何将参数传递给间接对象

我知道TypedFactory工具只会将给定的参数传递给它正在解析的对象。但是有没有一种方法可以将相同的参数传递给所有正在解析的间接对象呢

我一直在尝试使用定义为

public class ArgumentPassThrough : IScopeAccessor
    {
        private static IDictionary _args;
        public void Dispose()
        {
            _args = null;
        }

        public ILifetimeScope GetScope(CreationContext context)
        {
            var h = context.Handler;
            if (_args == null)
            {
                _args = context.AdditionalArguments;
            }
            else
            {
                var enumerator = _args.GetEnumerator();
                enumerator.Reset();
                while (enumerator.MoveNext())
                {
                    if (!context.AdditionalArguments.Contains(enumerator.Key))
                    {
                        context.AdditionalArguments.Add(enumerator.Key, enumerator.Value);
                    }
                }
            }

            return new DefaultLifetimeScope();
        }
    }

我的班级结构如下：

        public class Child2
        {
            public Child2(Child1 child1)
            {
                Child1 = child1;
            }

            public Child1 Child1 { get; private set; }
        }

        public class Child1
        {
            public Child1()
            {
            }
        }


public class Parent
{
            public Parent(Child1 child1, Child2 child2)
            {
                Child1 = child1;
                Child2 = child2;
            }

            public Child1 Child1 { get; private set; }
            public Child2 Child2 { get; private set; }
    }

    public interface IParentFactory
    {
        Parent Create(Child1 child1);
    }

我在windsorcontainer中向以下人员注册：

    public void ScopedFactory()
    {
        _container.Register(

            Component.For<IParentFactory>().AsFactory(),
            Component.For<Parent>().LifestyleScoped<ArgumentPassThrough>(),
            Component.For<Child2>().LifestyleScoped<ArgumentPassThrough>(),

            Classes.FromThisAssembly().Pick()
                   .WithService.Self()
                   .LifestyleTransient()
            );
    }

我使用它就像：

    [Test]
    public void ScopedFactoryDependency()
    {
        _demoModule.ScopedFactory();
        var fac = _container.Resolve<IParentFactory>();

        var p1 = AssertPassThrough(fac);
        var p2 = AssertPassThrough(fac);
        Assert.AreNotSame(p1,p2);
    }

    private Parent AssertPassThrough(IParentFactory fac)
    {
        Parent parent;
        var c1 = _container.Resolve<Child1>();
        using (_container.BeginScope())
        {
            parent = fac.Create(c1);
            Assert.AreSame(parent.Child1, c1);
            Assert.AreSame(parent.Child2.Child1, c1);
        }
        return parent;
    }

---

第一个过程是有效的，但我希望当_contaier.BeginScope存在于using块时，ScopeAccesor会被释放。这种情况不会发生，第二次传递的参数与第一次传递的参数相同。

你是说使用块没有调用Dispose吗？是的。我希望在IScopeAccessor.Dispose中收到通知，但当IWindsorContainer.BeginScope存在于using语句之外时，它不会被调用。