如何通过Func从SingleInstance组件中解析InstancePerLifetimeScope组件?

这个想法很简单,可以在其他容器中使用,不受限制。净值: 从请求上下文中引用的单例组件引用了瞬态组件,而瞬态组件又引用了请求范围内的组件(某些工作单元)。

我预计Autofac将在这两种情况下解析相同的作用域组件: -当我直接从请求范围请求时 -当我通过调用Func请求时(<)&燃气轮机; 不幸的是,实际情况有点不同-Autofac将SingleInstance组件粘贴到根范围,并在上解析InstancePerLifetimeScope组件 导致内存泄漏的根组件(!!!)因为UnitOfWork是一次性的,并且由根作用域跟踪(尝试使用匹配的web请求作用域只会找不到请求作用域,这更容易引起误解)。

现在我想知道这样的行为是出于设计还是仅仅是一个bug?如果它是设计的,我不确定它的用例是什么,以及为什么它与其他容器不同。

示例如下(包括正在使用的SimpleInjector案例):

namespace AutofacTest
{
using System;
using System.Linq;
using System.Linq.Expressions;

using Autofac;

using NUnit.Framework;

using SimpleInjector;
using SimpleInjector.Lifestyles;

public class SingletonComponent
{
    public Func<TransientComponent> Transient { get; }

    public Func<ScopedComponent> Scoped { get; }

    public SingletonComponent(Func<TransientComponent> transient, Func<ScopedComponent> scoped)
    {
        Transient = transient;
        Scoped = scoped;
    }
}

public class ScopedComponent : IDisposable
{
    public void Dispose()
    {
    }
}

public class TransientComponent
{
    public ScopedComponent Scoped { get; }

    public TransientComponent(ScopedComponent scopedComponent)
    {
        this.Scoped = scopedComponent;
    }
}

class Program
{
    static void Main(string[] args)
    {
        try
        {
            AutofacTest();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }

        try
        {
            SimpleInjectorTest();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }

   private static void AutofacTest()
    {
        var builder = new ContainerBuilder();
        builder.RegisterType<ScopedComponent>().InstancePerLifetimeScope();
        builder.RegisterType<SingletonComponent>().SingleInstance();
        builder.RegisterType<TransientComponent>();

        var container = builder.Build();

        var outerSingleton = container.Resolve<SingletonComponent>();

        using (var scope = container.BeginLifetimeScope())
        {
            var singleton = scope.Resolve<SingletonComponent>();
            Assert.That(outerSingleton, Is.SameAs(singleton));

            var transient = scope.Resolve<TransientComponent>();
            var scoped = scope.Resolve<ScopedComponent>();

            Assert.That(singleton.Transient(), Is.Not.SameAs(transient));
            // this fails
            Assert.That(singleton.Transient().Scoped, Is.SameAs(scoped));
            Assert.That(transient.Scoped, Is.SameAs(scoped));

            Assert.That(singleton.Scoped(), Is.SameAs(scoped)); // this fails
            Assert.That(singleton.Transient(), Is.Not.SameAs(transient));
        }
    }

    private static void SimpleInjectorTest()
    {
        var container = new SimpleInjector.Container();
        container.Options.AllowResolvingFuncFactories();
        container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();

        container.Register<ScopedComponent>(Lifestyle.Scoped);
        container.Register<SingletonComponent>(Lifestyle.Singleton);
        container.Register<TransientComponent>(Lifestyle.Transient);
        container.Verify();

        var outerSingleton = container.GetInstance<SingletonComponent>();

        using (var scope = AsyncScopedLifestyle.BeginScope(container))
        {
            var singleton = container.GetInstance<SingletonComponent>();
            Assert.That(outerSingleton, Is.SameAs(singleton));

            var transient = container.GetInstance<TransientComponent>();
            var scoped = container.GetInstance<ScopedComponent>();

            Assert.That(singleton.Transient(), Is.Not.SameAs(transient));
            Assert.That(singleton.Transient().Scoped, Is.SameAs(scoped));
            Assert.That(transient.Scoped, Is.SameAs(scoped));

            Assert.That(singleton.Scoped(), Is.SameAs(scoped));
            Assert.That(singleton.Transient(), Is.Not.SameAs(transient));
        }
    }
}

public static class SimpleInjectorExtensions
{
    public static void AllowResolvingFuncFactories(this ContainerOptions options)
    {
        options.Container.ResolveUnregisteredType += (s, e) =>
            {
                var type = e.UnregisteredServiceType;

                if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(Func<>))
                {
                    return;
                }

                Type serviceType = type.GetGenericArguments().First();

                InstanceProducer registration = options.Container.GetRegistration(serviceType, true);

                Type funcType = typeof(Func<>).MakeGenericType(serviceType);

                var factoryDelegate = Expression.Lambda(funcType, registration.BuildExpression()).Compile();

                e.Register(Expression.Constant(factoryDelegate));
            };
    }
}

}