IEnumerable-更新foreach循环内的对象

本文关键字：对象 循环 更新 foreach IEnumerable- | 更新日期: 2023-09-27 18:26:52

我有一个非常简单的程序，它创建了一堆对象，并对它们进行迭代，以设置每个对象的Priority属性。

static void Main(string[] args)
{
    foreach (var obj in ObjectCreator.CreateObjectsWithPriorities())
        Console.WriteLine(String.Format("Object #{0} has priority {1}",
                                         obj.Id, obj.Priority));
}
class ObjectCreator
{
    public static IEnumerable<ObjectWithPriority> CreateObjectsWithPriorities()
    {
        var objs = new[] { 1, 2, 3 }.Select(i => new ObjectWithPriority() { Id = i });
        ApplyPriorities(objs);
        return objs;
    }
    static void ApplyPriorities(IEnumerable<ObjectWithPriority> objs)
    {
        foreach (var obj in objs)
        {
            obj.Priority = obj.Id * 10;
            Console.WriteLine(String.Format("Set priority of object #{0} to {1}", obj.Id, obj.Priority));
        }
    }
}
class ObjectWithPriority
{
    public int Id { get; set; }
    public int Priority { get; set; }
}

我希望Main方法中的IEnumerable包含优先级已修改的对象。但是，它们都具有默认值0。这是日志：

Set priority of object #1 to 10 
Set priority of object #2 to 20 
Set priority of object #3 to 30 
Object #1 has priority 0 
Object #2 has priority 0 
Object #3 has priority 0

这种行为的原因是什么？为了让我的优先事项发挥作用，我应该在这里改变什么？

IEnumerable-更新foreach循环内的对象

执行此操作时：

var objs = new[] { 1, 2, 3 }.Select(i => new ObjectWithPriority() { Id = i });

您只需创建一个延迟求值迭代器，这不会分配一个数组/列表来存储您项目的ObjectWithPriorty。每次枚举迭代器时，它都会再次迭代值，并为每次迭代投影一个ObjectWithPriority，但会丢弃它们。

您想要做的是在传递查询之前将其具体化，这样以后您将实际修改已经分配的列表/数组。这可以使用Enumerable.ToList或Enumerable.ToArray:实现

public static IEnumerable<ObjectWithPriority> CreateObjectsWithPriorities()
{
    var objs = new[] { 1, 2, 3 }.Select(i => new ObjectWithPriority() { Id = i })
                                .ToList();
    ApplyPriorities(objs);
    return objs;
}

您可以额外使用Enumerable.Range，而不是分配一个固定大小的数组，这将根据请求延迟投影数字：

var objs = Enumerable.Range(1, 3).Select(i => new ObjectWithPriority { Id = i })
                                 .ToList();

为了更好地理解程序中发生的事情，您应该考虑以下表达式

var objs = new[] { 1, 2, 3 }.Select(i => new ObjectWithPriority() { Id = i });

作为查询，而不是作为对象的序列/列表/集合。

但从您的代码中可以明显看出，在这个特定的程序中，您不需要查询。您需要一个集合，该集合具有有限数量的对象，并且每次使用foreach循环时都会返回相同的对象。

因此，应该使用ICollection<ObjectWithPriority>而不是IEnumerable<ObjectWithPriority>。这将更好地代表程序的逻辑，并有助于避免一些错误/误解，比如你偶然发现的错误/误解。

代码可以修改如下：

public static ICollection<ObjectWithPriority> CreateObjectsWithPriorities()
{
    IEnumerable<ObjectWithPriority> queryThatProducesObjectsWithPriorities = new[] { 1, 2, 3 }.Select(i => new ObjectWithPriority() { Id = i }); // just for clarification
    ICollection<ObjectWithPriority> objectsWithPriorities = queryThatProducesObjectsWithPriorities.ToList();
    ApplyPriorities(objectsWithPriorities);
    return objectsWithPriorities;
}
static void ApplyPriorities(ICollection<ObjectWithPriority> objs)
{
    foreach (var obj in objs)
    {
        obj.Priority = obj.Id * 10;
        Console.WriteLine(String.Format("Set priority of object #{0} to {1}", obj.Id, obj.Priority));
    }
}

除了Yuval Itzchakov的答案：

如果你想延迟加载你的对象的优先级，你可以：

只为一个对象定义ApplyPriorities()方法，并在选择方法中使用它，或者向ObjectWithPriority类添加一个委托，该类计算优先级，如下代码所示：

class ObjectWithPriority
{
    public int Id { get; set; }
    private int? priority;
    public int Priority {
        get
        {
            return (priority.HasValue ? priority.Value : (priority = PriorityProvider(this)).Value);
        }
        set { priority = value; }
    }
    Func<ObjectWithPriority, int> PriorityProvider { get; set; }
    public ObjectWithPriority(Func<ObjectWithPriority, int> priorityProvider = null)
    {
        PriorityProvider = priorityProvider ?? (obj => 10 * obj.Id);
    }
}
相关文章：