c# - 在不破坏类结构的情况下在包含的类中向量化操作

Question

我当前的项目被分成多个类，这些类正确地代表了我们对系统中实体的看法。然而，这是以性能为代价的，因此我试图想出一种在保持当前类结构的同时提高性能的方法。

我认为一个例子最能说明问题:假设我有一个 Order包含多个 Item 的类秒。运输 Order 的简单实现正在运送其所有 Item小号:

class Order 
{
    private List<Item> m_items;

    public void Ship()
    {
        foreach (Item item in m_items)
        {
            item.Ship();
        }
    }
}

运送 Item是一个多阶段过程:

class Item
{
    public void Ship()
    {
        var receipt = m_boat.ShipToDestination(this);
        ProcessReceipt(receipt);
    }
}

事实证明，运送 Item在 Boat 上花费很长时间。幸运的是，Boat可以发货多个Item s 同时 ( List<Receipt> Boat.ShipToDestination(List<Item> items) )。但是，要使用此方法，我将不得不重写 Order.Ship()如下:

class Order 
{
    public void Ship()
    {
        var receipts = m_boat.ShipToDestination(m_items);
        foreach (Receipt receipt in receipts)
        {
            ProcessReceipt(receipt);
        }
    }
}

这意味着ProcessReceipt现在是 Order 的一部分(而不是 Item )，还有一个 Item不再负责其所有运输物流。

在我的真实代码中有很多方法都存在这个问题，所以有效地使用这个解决方案意味着大多数 Item逻辑将移入 Order类(class)。然而，这似乎是错误的逻辑所在——它确实应该在 Item 中。 .

我考虑过使用多线程(例如使用 Task 每个 Item )但这似乎太浪费了，特别是因为 Order可以有几十个Items .

我考虑的另一种方法是创建一个 QueuedBoat用QueueForShipping(Item item)方法和 ShipQueuedItems()方法。现在Order可以调用ShipQueuedItems同时 Item可以调用QueueForShipping .这种方法的问题在于，在我的真实代码中，Receipt仅在 Item 之后返回已发货，因此代码必须如下所示:

class Order 
{
    private List<Item> m_items;

    public void Ship()
    {
        foreach (Item item in m_items)
        {
            item.Ship();
        }

        m_queuedBoat.ShipQueuedItems();

        foreach (Item item in m_items)
        {
            item.FinalizeShipping();
        }
    }
}


class Item
{
    public void Ship()
    {
        m_queuedBoat.QueueForShipping(this);
    }

    public void FinalizeShipping()
    {
        ProcessReceipt(m_queuedBoat.GetReceiptForItem(this));
    }
}

感觉方向是对的(因为 Order 知道它有多少个 Item ，它一定是知道什么时候一切都在 Boat 上的组件)，但它破坏了 Ship分为两个阶段。在我的真实代码中，我有多个阶段(每个阶段都可以单独矢量化)，因此该方法将被分成 3-4 部分，这不是一个漂亮的景象。

有人可以建议一种向量化 Item.Ship() 的方法吗？同时将业务逻辑保留在 Item 中类，还是我必须放弃订单/项目分离才能利用矢量化？

编辑:

另一种方法可能是这样的:

class Order 
{
    private List<Item> m_items;

    public void Ship()
    {
        for (int i = 0; i < m_items.Count; ++i)
        {
            bool isLast = (i == (m_items.Count - 1));
            item.Ship(isLast);
        }
    }
}

class Item
{
    public void Ship(bool isLast)
    {
        m_queuedBoat.QueueForShipping(this, FinalizeShipping);
        if (isLast) m_queuedBoat.ShipQueuedItems();
    }

    private void FinalizeShipping(Receipt receipt)
    {
        ProcessReceipt(receipt);
    }
}

哪里QueuedBoat类使用其 Receipt 为每个项目调用回调.

Answer 1

好吧，无论如何 Ship 是一种异步操作:必须同时运行多个。所以必须是两个阶段:PrepareShipping(无效)和PerformShipping(等待实际运输完成并返回处理其收据)。

我想要这样的东西:

class Item
{
    public void PrepareShiping()
    {
        m_queuedBoat.QueueForShipping(this);
    }

    public void PerformShipping()
    {
        m_queuedBoat.StartActualShippingIfNotAlreadyStarted();
        m_queuedBoat.WaitForShippingEnd();
        ProcessReceipt(m_queuedBoat.GetReceiptForItem(this));
    }
}

所以订单可以是这样的:

class Order 
{
    public void PrepareShipping()
    {
        foreach (Item item in m_items)
            item.PrepareShiping();
    }

    public void PerformShipping()
    {
        foreach (Item item in m_items)
            item.PerformShipping();
    }

    // and for those who don't need asynchronity
    public void Ship()
    {
        PrepareShipping();
        PerformShipping();
    }
}

该程序可以在发货过程中执行其他操作，即在 Order.PrepareShipping() 和 Order.PerformShipping() 之间(例如，发货还有其他订单，可能在同一条船上)。