使用 Simple Injector 时放置 AsyncScopedLifestyle 的位置

Question

我正在编写一个在呼叫中心使用的应用程序。每当电话打到工作站时，我都需要创建一组对象（可能大约 30 个）。我希望这些对象仅在通话期间存在，因为它们包含状态，并且我认为创建新对象比尝试在每次通话时重置它们的状态更有意义。在创建这些对象时，它必须执行一些异步活动，例如为其他应用程序建立多个套接字并向它们发送消息。当电话结束时，它必须做更多的异步操作，例如发送结束通话消息，然后关闭套接字。

我一直在研究 Simple Injector 的 AsyncScopedLifestyle 功能。这是我认为如何使用它的简化示例：

class CallTaskFactory
{
    private readonly Container Container;

    public CallTaskFactory(Container container)
    {
        Container = container;
    }

    public async Task CreateCallTask()
    {
        using (Scope scope = AsyncScopedLifestyle.BeginScope(Container))
        {
            // Get the socket's destination
            SocketDestinationProvider socketDestProvider =
                Container.GetInstance<SocketDestinationProvider>();

            EndPoint ep = await socketDestProvider.GetSocketDestination();

            // Now create a socket and connect to that destination
            Socket socket = Container.GetInstance<Socket>();
            await socket.ConnectAsync(ep);

            // Send a simple message on the socket
            var Sender1 = Container.GetInstance<MessageSender1>();
            await Sender1.SendStartMessage();

            // Send another message, and the response tells us whether we need
            // to create some object that does something on a timer
            var Sender2 = Container.GetInstance<MessageSender2>();
            var Response = await Sender2.SendStartMessageAndAwaitResponse();
            if (Response.Result)
            {
                Container.GetInstance<ClassThatChecksSomethingOnATimer>();
            }

            // The call stays active until the socket closes
            TaskCompletionSource<int> Completion = new TaskCompletionSource<int>();
            socket.Closed += (sender, e) => { Completion.TrySetResult(0); };
            await Completion.Task;

            // Clean up
            await Sender2.SendStopMessage();
            await Sender1.SendStopMessage();
            await socket.DisconnectAsync();
        }
    }
}

不过，我不确定我是否将其放置在正确的位置。我假设这个工厂类必须存在于我的 Composition Root 中，因为它引用了一个特定的 DI 容器。但对我而言，Composition Root 仅用于组合对象图，并且通常它没有使用这些对象的逻辑，就像上面的代码那样。

如何在一个地方创建一组对象并在另一个地方使用它们，然后在它们的工作完成时销毁它们？

Answer 1

我假设这个工厂类必须存在于我的组合根目录中，因为它引用了一个特定的 DI 容器。

当然。只有Composition Root 应该引用容器。这通常意味着您需要引入抽象。这允许您实现依赖于您的合成根内部的 DI 容器的适配器逻辑，而应用程序代码可以依赖于它的抽象。

但对我来说，组合根仅用于组合对象图，通常它没有使用这些对象的逻辑，就像上面的代码那样。

您应该避免将业务逻辑放在组合根中。组合根是应用程序基础设施的一部分。不过，这并不意味着它只能组成对象图。允许调用创建的对象图。如果不允许对组合对象图进行操作，将很难做任何有用的事情。

如何在一个地方创建一组对象并在另一个地方使用它们，然后在它们的工作完成时销毁它们？

要解决这个问题，你应该尝试从不同的角度来解决这个问题。理想情况下，您的 Composition Root 应该只对 GetInstance 进行一次调用，并对已解析的对象进行一次方法调用。这通常可以通过将所有代码包装在一个新类中来实现。解析的依赖项将被提升为新类中的构造函数参数。

当你将这种技术应用到你的代码中时，你最终会得到这样的结果：

public class CallExecutor {
    ...        
    public CallExecutor(
        SocketDestinationProvider socketDestinationProvider, Socket socket,
        MessageSender1 messageSender1, MessageSender2 messageSender2,
        ClassThatChecksSomethingOnATimer checker)
    {
        this.socketDestinationProvider = socketDestinationProvider;
        this.socket = socket;
        this.messageSender1 = messageSender1;
        this.messageSender2 = messageSender2;
        this.checker = checker;
    }
    
    public async Task Call()
    {
        EndPoint ep = await this.socketDestProvider.GetSocketDestination();
        await this.socket.ConnectAsync(ep);
        await this.sender1.SendStartMessage();
        var response = await this.sSender2.SendStartMessageAndAwaitResponse();
        if (response.Result)
        {
            this.checker.DoSomething(...)
        }

        TaskCompletionSource<int> Completion = new TaskCompletionSource<int>();
        socket.Closed += (sender, e) => { Completion.TrySetResult(0); };
        await Completion.Task;

        await this.sender2.SendStopMessage();
        await this.sender1.SendStopMessage();
        await this.socket.DisconnectAsync();        
    }
}

在上面的代码中，我做了一个简单的一对一转换。每个解析都成为构造函数依赖项。这可能并非在所有情况下都是正确的。例如，我可以想象您想从容器中解析多个 Socket 实例。但是请注意，Socket 在我看来更像是运行时数据。您可能需要考虑避免使用 Container 来解析此类对象（正如在 this article 中提到的那样）。

这个新的CallExecutor 类可以完全定义为应用程序代码；不依赖于 DI 容器。 CallTaskFactory 的剩余代码非常短，可以在您的 Composition Root 中轻松实现：

class CallTaskFactory : ICallTaskFactory
{
    private Container container;
    
    public CallTaskFactory(Container container)
    {
        this.container = container;
    }

    public async Task CreateCallTask()
    {
        using (AsyncScopedLifestyle.BeginScope(this.container))
        {
            await this.container.GetInstance<CallExecutor>().Call();
        }
    }
}

然而，CallExecutor 的引入确实导致所有依赖项都被急切地创建。这可能看起来效率低下，但不应该是这样，因为object composition should be fast，所以你可以compose your graphs with confidence。与 Simple Injector 结合使用时，您几乎不会遇到性能问题，因为 Simple Injector 可以在瞬间轻松创建数千个对象。