c# 中重复 where() 与多个集合

Question

我有一个对象 A 的集合。每个 A 都有一个与对象 B 相关的字段 - 我有另一个集合。换句话说，每个 B 都附加到 As 集合的一个子集（但只是在概念上，而不是在代码中）。该字段（将 A 与 B 相关联）可以在系统的生命周期内发生变化。有一些系统要求阻止了这种结构的改变。

如果我需要对每个 B 的 A 集合重复执行操作，最好对 A 的集合重复使用 Where() 方法还是创建 B 拥有的另一个集合和一个管理添加和删除的类的相关项目。

让我看看我是否可以在代码中捕获它：

    class A {
      public B owner;
      ...
    }

    class B {
      ...
    }

    class FrequentlyCalledAction {
      public DoYourThing(B current) {
        List<A> relevantItems = listOfAllAItems.Where(x => x.owner == current).ToList()
        foreach (A item in relevantItems) {
          ...
        }
      }
    }

对比：

    class A {
      public B owner;
      ...
    }

    class B {
      public List<A> itsItems;
    }

    class FrequentlyCalledAction {
      public void DoYourThing(B current) {
        foreach (A item in current.itsItems) {
          ...
        }
      }
    }

    class AManager {
      public void moveItem(A item, B from, B to) {
        from.itsItems.remove(item);
        to.itsItems.add(item);
      }
    }

Answer 1

这主要取决于集合的大小。如果只有几个项目，则解决方案 two 带来的开销大于性能增益。

在这种情况下，我会使用解决方案 one，因为它具有更好的可读性并且管理起来不太复杂。

如果集合中有数千个项目，我会选择解决方案两个。 moveItems 方法是一个 O(n) 操作，但在您的场景中，读取次数似乎多于写入次数。因此，您可以通过更结构化的设计获得更多性能。

Answer 2

事实上，这一切都取决于您收藏的大小。 Sol 2 更复杂，但对于大型收集更快，而 sol1 对于少于 100/1000 个左右的项目可能非常快。

Answer 3

由于集合很小（约 100 个项目）并且它们经常更改（约每 4 次迭代），请执行此操作，然后看看您是否有问题。

public DoYourThing(B current)
{
    foreach(A item in listOfAllAItems.Where(a => a.owner == current))
    {
        ...
    }
}

我认为将 IEnumrable 转换为 IList 没有任何意义。

如果这给您带来性能问题，我认为AManager 不是您的最佳答案，尽管这可能取决于关系的变化程度。

Answer 4

如果您选择解决方案 2，则可能值得使用 HashSet 而不是 List。 HashSet 是 O(1) 添加和删除，而 List 是 O(1) 添加和 O(n) 删除。

另一个选项是这样的，它的优点是 A 和 B 的用户不需要记住使用AManager：

static class GlobalDictionary
{
  private static Dictionary<B,HashSet<A>> dictionary = new Dictionary<B,HashSet<A>>();

  public static HashSet<A> this[B obj]
  {
    // You could remove the set and have it check to see if a Set exists for a B
    // if not you would create it.
    get {return dictionary[obj];}
    set {dictionary[obj] = value;}
  }
} 


class A 
{
  private B owner;  
  public B Owner
  {
    get{ return owner;}
    set
    {
      if (owner != null) GlobalDictionary[owner].Remove(this);

      owner = value;
      GlobalDictionary[owner].Add(this);
    }
  }
}

class B
{
  public B()
  {
    GlobalDictionary[this] = new HashSet<A>();
  }

  public IEnumerable<A> Children
  {
    get
    {
      return GlobalDictionary[this];
    }
  }
}

我还没有尝试过，所以它可能需要一些调整，但你应该明白了。