c# - 迭代器变量在它来自的 IEnumerable 中不存在吗？

Question

我有一个方法看起来像

private Component[] AssociateComponentsWithParametersAndValues(
            IEnumerable<Component> components,
            IEnumerable<ComponentParameter> parameters,
            IEnumerable<ComponentParameterValue> values
            )
        {
            var componentsDictionary = new Dictionary<string, Component>();
            var parametersDictionary = new Dictionary<string, ComponentParameter>();
            var valuesDictionary = new Dictionary<string, ComponentParameterValue>();
            foreach (Component c in components)
            {
                bool componentMatch = components.Any(co => co == c);
                bool identifierMatch = components.Any(co => co.Identifier == c.Identifier);
                if (!componentsDictionary.ContainsKey(c.Identifier))
                    componentsDictionary.Add(c.Identifier, c);
            }
            // Do a bunch of stuff to mutate the components
            return components.ToArray();
        }

你会认为 componentMatch和 identifierMatch每次都是真的吗？相反， componentMatch总是假的和 identifierMatch永远是真的。此外，标识符(几乎，偶尔有一些坏数据)总是唯一的，所以它不可能找到具有相同标识符的另一个组件。
所以，Component 类一定有什么奇怪的地方。嗯，这就是它的样子

public class Component : ConfigurationObject
    {
        public string Parent { get; set; }
        public string Type { get; set; }
        public string Module { get; set; }
        public string Code { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public string TypeName { get; set; }
        public bool? Enabled { get; set; }
        public string DBIdentifier { get; set; }
        public Dictionary<string, ComponentParameterAndValues> ParametersAndValues { get; set; }
        public override string Identifier => DBIdentifier;
    }

这是它实现的类

public abstract class ConfigurationObject
    {
        public abstract string Identifier { get; }
    }

为什么会这样？

Answer 1

我能看到这个中断的唯一方法是如果 IEnumerable<Component> components是一个惰性求值的枚举，每次都返回新的迭代器对象。这有效:

var list = new List<Component>
{
    new Component { Identifier = "Foo" },
    new Component { Identifier = "Bar" },
    new Component { Identifier = "Baz" },
};

foreach (Component c in list)
{
    bool componentMatch = list.Any(co => co == c);
    Console.WriteLine($"Component {c.Identifier} match: {componentMatch}");
}

因为 ==检查引用相等性(除非 Component 覆盖它，但它看起来不像)。但是，如果它不是列表，而是每次迭代的新结果:

IEnumerable<Component> list = GetList();

foreach (Component c in list)
{
    bool componentMatch = list.Any(co => co == c);
    Console.WriteLine($"Component {c.Identifier} match: {componentMatch}");
}

private static IEnumerable<Component> GetList()
{
    yield return new Component { Identifier = "Foo" };
    yield return new Component { Identifier = "Bar" };
    yield return new Component { Identifier = "Baz" };
}

然后打印 false , 因为 foreach()和 Any()每个都获得一个新对象的新集合，因此它们的引用不匹配。
解决方案是枚举一次，并存储一次组件，具体化在列表中，然后使用它:

var localComponents = components.ToList();

foreach (Component c in localComponents)
{
    // ...
}