为什么 IEnumerable向集合添加元素后变空？

Question

• 我有一个 IEnumerable，当我迭代它并将其元素添加到列表中时，它会变成空吗？

• 我对它的期望通常有什么问题吗 ？代码？

  苹果公共类
  {
      私人ICollection<水果> _fruits = new List();
  
      public void AddFruits(IEnumerablefruits)
      {
          if (fruits == null) throw new ArgumentNullException("fruits");
          foreach（水果中的水果）
          {
              _fruits.Add(水果);
          }
      }
  }
  

  调用者代码：

  public void AddFruits(IEnumerablefruitsToAdd)
  {
      foreach（苹果中的苹果）
      {
          // 这里fruitsToAdd 有元素，fruitsToAdd.ToList() 有两个水果。
          苹果.AddFruits(fruitsToAdd);
          // 这里的fruitsToAdd 没有元素！！，fruitsToAdd.ToList() 是空的！
          // 下一次迭代不会向下一个苹果添加任何水果，因为fruitsToAdd 为空。
      }
  }
  

更新

ToList() 解决了问题。问题的根源在于 AddFruits(IEnumerablefruitsToAdd) 的调用者发送了类似的fruitsToAdd。

FruitsToAdd = obj.Fruits.Except(apples.Fruits);

每次 IEnumerablefruitsToAdd 为 Rest 时，它都会在上面的语句上运行。在下一次迭代中运行 except ，因此没有返回任何结果。

正确的方法是fruitsToAdd = obj.Fruits.Except(apples.Fruits).ToList();因为我们想要一个评估。

Answer 1

好吧，试试这个：

public void AddFruits(IEnumerable<Fruit> fruitsToAdd)
{
    var fruitsToAddCopy = fruitsToAdd.ToList();  // add just this line

    foreach (var apple in apples)
    {           
        apple.AddFruits(fruitsToAddCopy);    // and change this        
    }
}

如果不知道 fruitsToAdd 的来源，就不可能说更多。某些 IEnumerable 无法重复使用。其他人可以。

Answer 2

我修改了你的代码以使其编译并编写了一个测试。将其元素复制到苹果中后，您的列表不会变空。

    using System;
    using System.Collections.Generic;
    using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace ClassLibrary3
{
    [TestClass]
    public class Class1
    {
        [TestMethod]
        public void test()
        {
            var fruits = new List<Fruit> {new Fruit(), new Fruit(), new Fruit()};

            var lists = AddFruits(fruits);
            Assert.IsTrue(fruits.Count == 3);

        }

        public List<Apple> AddFruits(IEnumerable<Fruit> fruitsToAdd)
        {
            var apples = new List<Apple>
                             {
                                 new Apple(),
                                 new Apple()
                             };

            foreach (var apple in apples)
            {
                apple.AddFruits(fruitsToAdd);
            }
            return apples;
        }
    }

    public class Fruit 
    {
    }

    public class Apple
    {
        private ICollection<Fruit> _fruits = new List<Fruit>();

        public void AddFruits(IEnumerable<Fruit> fruits)
        {
            if (fruits == null) throw new ArgumentNullException("fruits");
            foreach (var fruit in fruits)
            {
                _fruits.Add(fruit);
            }
        }
    }
}

Answer 3

您问题中的代码不应表现出这种行为，因此我假设您尝试简化它，但从中删除了很多功能。

看起来有点可疑的是您的 _fruits 字段的类型为 ICollection。该接口通常与自定义集合实现一起使用。在实际代码中，该字段是否有可能不是使用 List 实例化的，而是使用该接口的自定义实现实例化的？

如果您有自定义集合实现，那么它的 Add 方法完全有可能执行奇怪的操作（例如在将项目添加到新的“父”集合之前从其先前的“父”集合中删除项目） 。树集合经常做这样的事情来简化移动节点。

[编辑]

我知道这不是OP的实际问题，但我仍然会添加一个示例来演示自定义集合实现实际上可以修改输入集合其成员被添加到不同的集合中。

假设 Fruit 类如下所示：

partial class Fruit
{
    private ICollection<Fruit> _children;
    private Fruit _parent;

    public String Name { get; set; }

    public Fruit()
    {
        _children = new FruitCollection(this);
    }

    public void AddFruits(IEnumerable<Fruit> fruits)
    {
        foreach (Fruit f in fruits)
            _children.Add(f);
    }

    public int NumberOfChildren
    {
        get { return _children.Count; }
    }

    public IEnumerable<Fruit> GetFruits()
    {
        return _children.ToList();
    }
}

并且有一个自定义集合定义为：

partial class Fruit
{
    public class FruitCollection : Collection<Fruit>
    {
        private readonly Fruit _parent;
        public FruitCollection(Fruit parent)
        {
            _parent = parent;
        }

        protected override void InsertItem(int index, Fruit item)
        {
            // item already has a parent?
            if (item._parent != null)
            {
                // remove it from previous parent
                item._parent._children.Remove(item);
            }

            // set the new parent
            item._parent = _parent;

            base.InsertItem(index, item);
        }

        // other methods should be overriden in a similar way
    }
}

然后以下程序：

static void Main(string[] args)
{
    List<Fruit> abc = new List<Fruit>()
    {
        new Fruit() { Name = "a" },
        new Fruit() { Name = "b" },
        new Fruit() { Name = "c" }
    };

    Fruit apple = new Fruit() { Name = "apple" };
    apple.AddFruits(abc);

    Console.WriteLine("{0} has {1} children", apple.Name, apple.NumberOfChildren);


    // now try to add apples's children to
    // each of the following fruits
    List<Fruit> def = new List<Fruit>()
    {
        new Fruit() { Name = "d" },
        new Fruit() { Name = "e" },
        new Fruit() { Name = "f" }
    };

    foreach (Fruit f in def)
    {
        f.AddFruits(apple.GetFruits());
        Console.WriteLine("{0} has {1} children", f.Name, f.NumberOfChildren);
    }

    Console.Read();
}

将打印：

    apple has 3 children

    d has 3 children
    e has 0 children
    f has 0 children

因为 apple.GetFruits() 将在之后返回 0第一次迭代。

通过查看自定义集合的源代码，很难意识到 AddFruits 中的 _children.Add(f) 实际上修改了以前的父集合的fruits。